From 9d1d224caf9f936e0ace0ee5854caefb660800f2 Mon Sep 17 00:00:00 2001 From: Daniel Smilkov Date: Thu, 3 Aug 2017 13:45:13 -0400 Subject: [PATCH] initial commit --- .gitignore | 5 + .npmignore | 9 + .npmrc | 1 + .vscode/settings.json | 15 + .vscode/tasks.json | 16 + CONTRIBUTING.md | 26 + LICENSE | 202 + README.md | 100 + bower.json | 38 + demos/adder/adder.ts | 71 + demos/adder/index.html | 34 + demos/benchmarks/benchmark-demo.html | 49 + demos/benchmarks/benchmark.ts | 40 + demos/benchmarks/bundle.js | 3788 +++++++ demos/benchmarks/conv_gpu_benchmark.ts | 90 + .../conv_transpose_gpu_benchmark.ts | 85 + demos/benchmarks/logsumexp_cpu_benchmark.ts | 32 + demos/benchmarks/logsumexp_gpu_benchmark.ts | 51 + demos/benchmarks/math-benchmark-run-groups.ts | 79 + demos/benchmarks/math-benchmark.html | 95 + demos/benchmarks/math-benchmark.ts | 225 + .../max_pool_backprop_gpu_benchmark.ts | 82 + demos/benchmarks/max_pool_gpu_benchmark.ts | 121 + demos/benchmarks/mulmat_cpu_benchmark.ts | 37 + demos/benchmarks/mulmat_gpu_benchmark.ts | 98 + demos/benchmarks/tex_util_benchmark.ts | 80 + demos/chartjs.d.ts | 448 + demos/deeplearnjs.ts | 18 + demos/demo-footer.html | 56 + demos/demo-footer.ts | 15 + demos/demo-header.html | 48 + demos/demo-header.ts | 15 + demos/font-embedding/bundle.js | 8217 ++++++++++++++ demos/homepage/Gemfile | 26 + demos/homepage/Gemfile.lock | 205 + demos/homepage/_config.yml | 32 + demos/homepage/_includes/footer.html | 32 + demos/homepage/_includes/header.html | 31 + demos/homepage/_layouts/default.html | 36 + demos/homepage/_layouts/page.html | 30 + demos/homepage/assets/style.css | 280 + demos/homepage/bundle.js | 8216 ++++++++++++++ demos/homepage/index.md | 256 + demos/homepage/index.ts | 150 + demos/imagenet/bundle.js | 9296 ++++++++++++++++ demos/imagenet/imagenet-demo.html | 49 + demos/imagenet/imagenet-demo.ts | 220 + demos/imagenet/imagenet.html | 114 + demos/imagenet/images/beerbottle.jpg | Bin 0 -> 4257 bytes demos/imagenet/images/cat.jpg | Bin 0 -> 24557 bytes demos/imagenet/images/dog1.jpg | Bin 0 -> 12279 bytes demos/imagenet/images/dog2.jpg | Bin 0 -> 14872 bytes demos/imagenet/images/piano.jpg | Bin 0 -> 10271 bytes demos/imagenet/images/saxophone.jpg | Bin 0 -> 5423 bytes demos/images/benchmark.png | Bin 0 -> 47293 bytes demos/images/font-embedding.png | Bin 0 -> 57566 bytes demos/images/imagenet.png | Bin 0 -> 417161 bytes demos/images/model-builder.png | Bin 0 -> 100516 bytes demos/images/nn-art.png | Bin 0 -> 96832 bytes demos/images/paint-image.png | Bin 0 -> 457134 bytes demos/mnist/fully_connected_feed.py | 253 + demos/mnist/hidden1_biases | 3 + demos/mnist/hidden1_weights | Bin 0 -> 401408 bytes demos/mnist/hidden2_biases | 1 + demos/mnist/hidden2_weights | Bin 0 -> 16384 bytes demos/mnist/index.html | 3 + demos/mnist/manifest.json | 41 + demos/mnist/mnist.md | 125 + demos/mnist/mnist.ts | 139 + demos/mnist/sample_data.json | 1 + demos/mnist/softmax_linear_biases | 1 + demos/mnist/softmax_linear_weights | Bin 0 -> 1280 bytes demos/model-builder/bundle.js | 9461 +++++++++++++++++ demos/model-builder/cifar10-conv.json | 1 + demos/model-builder/layer_builder.ts | 370 + demos/model-builder/mnist-conv.json | 1 + .../model-builder/mnist-fully-connected.json | 1 + .../model-builder-datasets-config.json | 43 + demos/model-builder/model-builder-demo.html | 55 + demos/model-builder/model-builder.html | 345 + demos/model-builder/model-builder.ts | 839 ++ demos/model-builder/model-layer.html | 135 + demos/model-builder/model-layer.ts | 190 + demos/model-builder/model_builder_util.ts | 18 + demos/model-builder/tensorflow.ts | 200 + demos/models/imagenet_classes.ts | 1034 ++ demos/models/imagenet_util.ts | 160 + demos/models/squeezenet.ts | 191 + demos/ndarray-image-visualizer.html | 25 + demos/ndarray-image-visualizer.ts | 90 + demos/ndarray-logits-visualizer.html | 45 + demos/ndarray-logits-visualizer.ts | 98 + demos/nn-art/bundle.js | 8264 ++++++++++++++ demos/nn-art/cppn.ts | 186 + demos/nn-art/nn-art-demo.html | 55 + demos/nn-art/nn-art.html | 97 + demos/nn-art/nn-art.ts | 126 + demos/nn-art/nn_art_util.ts | 179 + demos/one_plus_one/index.html | 22 + demos/one_plus_one/one_plus_one.ts | 52 + demos/paint-image/bundle.js | 8333 +++++++++++++++ demos/polymer-spec.ts | 64 + demos/xhr-dataset.ts | 195 + docs/roadmap.md | 72 + docs/tutorials/index.md | 24 + docs/tutorials/intro.md | 310 + docs/tutorials/ml_beginners.md | 303 + karma.conf.js | 31 + package.json | 35 + scripts/build-demo | 28 + scripts/build-npm.sh | 20 + scripts/build-standalone.sh | 18 + scripts/convert_uint8_tensor_to_png.py | 63 + scripts/deploy-demo | 36 + scripts/dump_checkpoint_vars.py | 100 + scripts/make-website.sh | 53 + scripts/watch-demo | 33 + src/checkpoint_loader.ts | 137 + src/checkpoint_loader_test.ts | 99 + src/dataset.ts | 266 + src/dataset_test.ts | 100 + src/graph.ts | 905 ++ src/graph_layers.ts | 51 + src/graph_runner.ts | 357 + src/graph_runner_test.ts | 204 + src/graph_test.ts | 621 ++ src/graph_util.ts | 132 + src/graph_util_test.ts | 225 + src/index.ts | 37 + src/initializers.ts | 125 + src/input_provider.ts | 169 + src/input_provider_test.ts | 140 + src/math/activation_functions.ts | 84 + src/math/activation_functions_test.ts | 97 + src/math/concat3d_util.ts | 49 + src/math/concat3d_util_test.ts | 66 + src/math/conv_util.ts | 73 + src/math/copy2d_util.ts | 27 + src/math/cost_functions.ts | 49 + src/math/cost_functions_test.ts | 49 + src/math/math.ts | 1065 ++ src/math/math_cpu.ts | 898 ++ src/math/math_cpu_test.ts | 1550 +++ src/math/math_gpu.ts | 1303 +++ src/math/math_gpu_test.ts | 2134 ++++ src/math/ndarray.ts | 569 + src/math/ndarray_test.ts | 338 + src/math/webgl/addscaledmat_gpu.ts | 84 + src/math/webgl/addscaledmat_gpu_test.ts | 75 + src/math/webgl/addsubmuldiv_gpu.ts | 116 + src/math/webgl/addsubmuldiv_gpu_test.ts | 214 + src/math/webgl/argmaxequals_gpu.ts | 62 + src/math/webgl/argmaxequals_gpu_test.ts | 63 + src/math/webgl/argminmax_gpu.ts | 90 + src/math/webgl/argminmax_gpu_test.ts | 119 + src/math/webgl/avg_pool_gpu.ts | 30 + src/math/webgl/avg_pool_gpu_test.ts | 112 + src/math/webgl/batchnorm_gpu.ts | 131 + src/math/webgl/batchnorm_gpu_test.ts | 217 + src/math/webgl/binaryop_gpu.ts | 78 + src/math/webgl/concat3d_gpu.ts | 74 + src/math/webgl/concat3d_gpu_test.ts | 105 + src/math/webgl/conv_backprop_gpu.ts | 252 + .../webgl/conv_backprop_gpu_derbias_test.ts | 74 + .../conv_backprop_gpu_derweights_test.ts | 120 + .../webgl/conv_backprop_transpose_gpu_test.ts | 144 + src/math/webgl/conv_gpu.ts | 151 + src/math/webgl/conv_gpu_getbiasvalue_test.ts | 85 + .../conv_gpu_getmatrixvalueorzeropad_test.ts | 139 + src/math/webgl/conv_gpu_test.ts | 413 + src/math/webgl/copy_gpu.ts | 63 + src/math/webgl/copy_gpu_test.ts | 189 + src/math/webgl/exp_gpu.ts | 36 + src/math/webgl/exp_gpu_test.ts | 49 + src/math/webgl/gpgpu_context.ts | 310 + src/math/webgl/gpgpu_context_test.ts | 421 + src/math/webgl/gpgpu_util.ts | 258 + src/math/webgl/gpgpu_util_test.ts | 117 + src/math/webgl/log_gpu.ts | 36 + src/math/webgl/log_gpu_test.ts | 50 + src/math/webgl/logsumexp_gpu.ts | 73 + src/math/webgl/logsumexp_gpu_test.ts | 54 + src/math/webgl/max_pool_backprop_gpu.ts | 101 + src/math/webgl/max_pool_backprop_gpu_test.ts | 141 + src/math/webgl/max_pool_gpu.ts | 44 + src/math/webgl/max_pool_gpu_test.ts | 114 + src/math/webgl/max_pool_positions_gpu_test.ts | 110 + src/math/webgl/min_pool_gpu.ts | 30 + src/math/webgl/min_pool_gpu_test.ts | 112 + src/math/webgl/minmax_gpu.ts | 66 + src/math/webgl/minmax_gpu_test.ts | 103 + src/math/webgl/mulbcast_gpu.ts | 90 + src/math/webgl/mulbcast_gpu_test.ts | 140 + src/math/webgl/mulmat_gpu.ts | 62 + src/math/webgl/mulmat_gpu_test.ts | 382 + src/math/webgl/mulmat_packed_gpu.ts | 130 + src/math/webgl/mulmat_packed_gpu_test.ts | 404 + src/math/webgl/neg_gpu.ts | 36 + src/math/webgl/neg_gpu_test.ts | 50 + src/math/webgl/pool_gpu.ts | 121 + src/math/webgl/reducesum_gpu.ts | 63 + src/math/webgl/reducesum_gpu_test.ts | 65 + src/math/webgl/relu_gpu.ts | 39 + src/math/webgl/relu_gpu_test.ts | 57 + src/math/webgl/render_ndarray_gpu_util.ts | 59 + .../webgl/render_ndarray_gpu_util_test.ts | 70 + src/math/webgl/reshape_gpu.ts | 65 + src/math/webgl/reshape_gpu_test.ts | 88 + src/math/webgl/resize_bilinear_gpu.ts | 92 + src/math/webgl/resize_bilinear_gpu_test.ts | 127 + src/math/webgl/shader_compiler.ts | 126 + src/math/webgl/sigmoid_gpu.ts | 37 + src/math/webgl/sigmoid_gpu_test.ts | 38 + src/math/webgl/step_gpu.ts | 39 + src/math/webgl/step_gpu_test.ts | 65 + src/math/webgl/tex_util.ts | 233 + src/math/webgl/tex_util_test.ts | 301 + src/math/webgl/texture_manager.ts | 92 + src/math/webgl/trig_gpu.ts | 66 + src/math/webgl/trig_gpu_test.ts | 57 + src/math/webgl/unaryop_gpu.ts | 55 + src/math/webgl/webgl_util.ts | 418 + src/operation_emitter.ts | 125 + src/ops/add.ts | 102 + src/ops/add_test.ts | 193 + src/ops/argmax.ts | 47 + src/ops/argmax_test.ts | 67 + src/ops/argmaxequals.ts | 50 + src/ops/argmaxequals_test.ts | 80 + src/ops/concat3d.ts | 57 + src/ops/concat3d_test.ts | 115 + src/ops/convolution.ts | 100 + src/ops/convolution_test.ts | 352 + src/ops/divide.ts | 114 + src/ops/divide_test.ts | 158 + src/ops/element_wise_activation.ts | 93 + src/ops/element_wise_activation_test.ts | 145 + src/ops/element_wise_cost.ts | 80 + src/ops/element_wise_cost_test.ts | 73 + src/ops/exp.ts | 56 + src/ops/exp_test.ts | 74 + src/ops/linear_combination.ts | 83 + src/ops/linear_combination_test.ts | 99 + src/ops/log.ts | 56 + src/ops/log_test.ts | 74 + src/ops/matmul.ts | 93 + src/ops/matmul_test.ts | 204 + src/ops/max_pool.ts | 72 + src/ops/max_pool_test.ts | 158 + src/ops/multiply.ts | 99 + src/ops/multiply_test.ts | 150 + src/ops/op.ts | 35 + src/ops/reduce_sum.ts | 62 + src/ops/reduce_sum_test.ts | 79 + src/ops/reshape.ts | 53 + src/ops/softmax.ts | 99 + src/ops/softmax_test.ts | 79 + src/ops/split.ts | 62 + src/ops/split_test.ts | 76 + src/ops/subtract.ts | 102 + src/ops/subtract_test.ts | 197 + src/optimizer.ts | 47 + src/priority_queue.ts | 223 + src/priority_queue_test.ts | 199 + src/session.ts | 285 + src/session_test.ts | 314 + src/session_util.ts | 304 + src/session_util_test.ts | 464 + src/sgd_optimizer.ts | 93 + src/tensor_array_map.ts | 107 + src/tensor_array_map_test.ts | 108 + src/test_util.ts | 92 + src/util.ts | 182 + src/util_test.ts | 89 + tsconfig-doc.json | 31 + tsconfig.json | 13 + tslint.json | 55 + 277 files changed, 93457 insertions(+) create mode 100644 .gitignore create mode 100644 .npmignore create mode 100644 .npmrc create mode 100644 .vscode/settings.json create mode 100644 .vscode/tasks.json create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 bower.json create mode 100644 demos/adder/adder.ts create mode 100644 demos/adder/index.html create mode 100644 demos/benchmarks/benchmark-demo.html create mode 100644 demos/benchmarks/benchmark.ts create mode 100644 demos/benchmarks/bundle.js create mode 100644 demos/benchmarks/conv_gpu_benchmark.ts create mode 100644 demos/benchmarks/conv_transpose_gpu_benchmark.ts create mode 100644 demos/benchmarks/logsumexp_cpu_benchmark.ts create mode 100644 demos/benchmarks/logsumexp_gpu_benchmark.ts create mode 100644 demos/benchmarks/math-benchmark-run-groups.ts create mode 100644 demos/benchmarks/math-benchmark.html create mode 100644 demos/benchmarks/math-benchmark.ts create mode 100644 demos/benchmarks/max_pool_backprop_gpu_benchmark.ts create mode 100644 demos/benchmarks/max_pool_gpu_benchmark.ts create mode 100644 demos/benchmarks/mulmat_cpu_benchmark.ts create mode 100644 demos/benchmarks/mulmat_gpu_benchmark.ts create mode 100644 demos/benchmarks/tex_util_benchmark.ts create mode 100644 demos/chartjs.d.ts create mode 100644 demos/deeplearnjs.ts create mode 100644 demos/demo-footer.html create mode 100644 demos/demo-footer.ts create mode 100644 demos/demo-header.html create mode 100644 demos/demo-header.ts create mode 100644 demos/font-embedding/bundle.js create mode 100644 demos/homepage/Gemfile create mode 100644 demos/homepage/Gemfile.lock create mode 100644 demos/homepage/_config.yml create mode 100644 demos/homepage/_includes/footer.html create mode 100644 demos/homepage/_includes/header.html create mode 100644 demos/homepage/_layouts/default.html create mode 100644 demos/homepage/_layouts/page.html create mode 100644 demos/homepage/assets/style.css create mode 100644 demos/homepage/bundle.js create mode 100644 demos/homepage/index.md create mode 100644 demos/homepage/index.ts create mode 100644 demos/imagenet/bundle.js create mode 100644 demos/imagenet/imagenet-demo.html create mode 100644 demos/imagenet/imagenet-demo.ts create mode 100644 demos/imagenet/imagenet.html create mode 100644 demos/imagenet/images/beerbottle.jpg create mode 100644 demos/imagenet/images/cat.jpg create mode 100644 demos/imagenet/images/dog1.jpg create mode 100644 demos/imagenet/images/dog2.jpg create mode 100644 demos/imagenet/images/piano.jpg create mode 100644 demos/imagenet/images/saxophone.jpg create mode 100644 demos/images/benchmark.png create mode 100644 demos/images/font-embedding.png create mode 100644 demos/images/imagenet.png create mode 100644 demos/images/model-builder.png create mode 100644 demos/images/nn-art.png create mode 100644 demos/images/paint-image.png create mode 100644 demos/mnist/fully_connected_feed.py create mode 100644 demos/mnist/hidden1_biases create mode 100644 demos/mnist/hidden1_weights create mode 100644 demos/mnist/hidden2_biases create mode 100644 demos/mnist/hidden2_weights create mode 100644 demos/mnist/index.html create mode 100644 demos/mnist/manifest.json create mode 100644 demos/mnist/mnist.md create mode 100644 demos/mnist/mnist.ts create mode 100644 demos/mnist/sample_data.json create mode 100644 demos/mnist/softmax_linear_biases create mode 100644 demos/mnist/softmax_linear_weights create mode 100644 demos/model-builder/bundle.js create mode 100644 demos/model-builder/cifar10-conv.json create mode 100644 demos/model-builder/layer_builder.ts create mode 100644 demos/model-builder/mnist-conv.json create mode 100644 demos/model-builder/mnist-fully-connected.json create mode 100644 demos/model-builder/model-builder-datasets-config.json create mode 100644 demos/model-builder/model-builder-demo.html create mode 100644 demos/model-builder/model-builder.html create mode 100644 demos/model-builder/model-builder.ts create mode 100644 demos/model-builder/model-layer.html create mode 100644 demos/model-builder/model-layer.ts create mode 100644 demos/model-builder/model_builder_util.ts create mode 100644 demos/model-builder/tensorflow.ts create mode 100644 demos/models/imagenet_classes.ts create mode 100644 demos/models/imagenet_util.ts create mode 100644 demos/models/squeezenet.ts create mode 100644 demos/ndarray-image-visualizer.html create mode 100644 demos/ndarray-image-visualizer.ts create mode 100644 demos/ndarray-logits-visualizer.html create mode 100644 demos/ndarray-logits-visualizer.ts create mode 100644 demos/nn-art/bundle.js create mode 100644 demos/nn-art/cppn.ts create mode 100644 demos/nn-art/nn-art-demo.html create mode 100644 demos/nn-art/nn-art.html create mode 100644 demos/nn-art/nn-art.ts create mode 100644 demos/nn-art/nn_art_util.ts create mode 100644 demos/one_plus_one/index.html create mode 100644 demos/one_plus_one/one_plus_one.ts create mode 100644 demos/paint-image/bundle.js create mode 100644 demos/polymer-spec.ts create mode 100644 demos/xhr-dataset.ts create mode 100644 docs/roadmap.md create mode 100644 docs/tutorials/index.md create mode 100644 docs/tutorials/intro.md create mode 100644 docs/tutorials/ml_beginners.md create mode 100644 karma.conf.js create mode 100644 package.json create mode 100755 scripts/build-demo create mode 100755 scripts/build-npm.sh create mode 100755 scripts/build-standalone.sh create mode 100644 scripts/convert_uint8_tensor_to_png.py create mode 100755 scripts/deploy-demo create mode 100644 scripts/dump_checkpoint_vars.py create mode 100755 scripts/make-website.sh create mode 100755 scripts/watch-demo create mode 100644 src/checkpoint_loader.ts create mode 100644 src/checkpoint_loader_test.ts create mode 100644 src/dataset.ts create mode 100644 src/dataset_test.ts create mode 100644 src/graph.ts create mode 100644 src/graph_layers.ts create mode 100644 src/graph_runner.ts create mode 100644 src/graph_runner_test.ts create mode 100644 src/graph_test.ts create mode 100644 src/graph_util.ts create mode 100644 src/graph_util_test.ts create mode 100644 src/index.ts create mode 100644 src/initializers.ts create mode 100644 src/input_provider.ts create mode 100644 src/input_provider_test.ts create mode 100644 src/math/activation_functions.ts create mode 100644 src/math/activation_functions_test.ts create mode 100644 src/math/concat3d_util.ts create mode 100644 src/math/concat3d_util_test.ts create mode 100644 src/math/conv_util.ts create mode 100644 src/math/copy2d_util.ts create mode 100644 src/math/cost_functions.ts create mode 100644 src/math/cost_functions_test.ts create mode 100644 src/math/math.ts create mode 100644 src/math/math_cpu.ts create mode 100644 src/math/math_cpu_test.ts create mode 100644 src/math/math_gpu.ts create mode 100644 src/math/math_gpu_test.ts create mode 100644 src/math/ndarray.ts create mode 100644 src/math/ndarray_test.ts create mode 100644 src/math/webgl/addscaledmat_gpu.ts create mode 100644 src/math/webgl/addscaledmat_gpu_test.ts create mode 100644 src/math/webgl/addsubmuldiv_gpu.ts create mode 100644 src/math/webgl/addsubmuldiv_gpu_test.ts create mode 100644 src/math/webgl/argmaxequals_gpu.ts create mode 100644 src/math/webgl/argmaxequals_gpu_test.ts create mode 100644 src/math/webgl/argminmax_gpu.ts create mode 100644 src/math/webgl/argminmax_gpu_test.ts create mode 100644 src/math/webgl/avg_pool_gpu.ts create mode 100644 src/math/webgl/avg_pool_gpu_test.ts create mode 100644 src/math/webgl/batchnorm_gpu.ts create mode 100644 src/math/webgl/batchnorm_gpu_test.ts create mode 100644 src/math/webgl/binaryop_gpu.ts create mode 100644 src/math/webgl/concat3d_gpu.ts create mode 100644 src/math/webgl/concat3d_gpu_test.ts create mode 100644 src/math/webgl/conv_backprop_gpu.ts create mode 100644 src/math/webgl/conv_backprop_gpu_derbias_test.ts create mode 100644 src/math/webgl/conv_backprop_gpu_derweights_test.ts create mode 100644 src/math/webgl/conv_backprop_transpose_gpu_test.ts create mode 100644 src/math/webgl/conv_gpu.ts create mode 100644 src/math/webgl/conv_gpu_getbiasvalue_test.ts create mode 100644 src/math/webgl/conv_gpu_getmatrixvalueorzeropad_test.ts create mode 100644 src/math/webgl/conv_gpu_test.ts create mode 100644 src/math/webgl/copy_gpu.ts create mode 100644 src/math/webgl/copy_gpu_test.ts create mode 100644 src/math/webgl/exp_gpu.ts create mode 100644 src/math/webgl/exp_gpu_test.ts create mode 100644 src/math/webgl/gpgpu_context.ts create mode 100644 src/math/webgl/gpgpu_context_test.ts create mode 100644 src/math/webgl/gpgpu_util.ts create mode 100644 src/math/webgl/gpgpu_util_test.ts create mode 100644 src/math/webgl/log_gpu.ts create mode 100644 src/math/webgl/log_gpu_test.ts create mode 100644 src/math/webgl/logsumexp_gpu.ts create mode 100644 src/math/webgl/logsumexp_gpu_test.ts create mode 100644 src/math/webgl/max_pool_backprop_gpu.ts create mode 100644 src/math/webgl/max_pool_backprop_gpu_test.ts create mode 100644 src/math/webgl/max_pool_gpu.ts create mode 100644 src/math/webgl/max_pool_gpu_test.ts create mode 100644 src/math/webgl/max_pool_positions_gpu_test.ts create mode 100644 src/math/webgl/min_pool_gpu.ts create mode 100644 src/math/webgl/min_pool_gpu_test.ts create mode 100644 src/math/webgl/minmax_gpu.ts create mode 100644 src/math/webgl/minmax_gpu_test.ts create mode 100644 src/math/webgl/mulbcast_gpu.ts create mode 100644 src/math/webgl/mulbcast_gpu_test.ts create mode 100644 src/math/webgl/mulmat_gpu.ts create mode 100644 src/math/webgl/mulmat_gpu_test.ts create mode 100644 src/math/webgl/mulmat_packed_gpu.ts create mode 100644 src/math/webgl/mulmat_packed_gpu_test.ts create mode 100644 src/math/webgl/neg_gpu.ts create mode 100644 src/math/webgl/neg_gpu_test.ts create mode 100644 src/math/webgl/pool_gpu.ts create mode 100644 src/math/webgl/reducesum_gpu.ts create mode 100644 src/math/webgl/reducesum_gpu_test.ts create mode 100644 src/math/webgl/relu_gpu.ts create mode 100644 src/math/webgl/relu_gpu_test.ts create mode 100644 src/math/webgl/render_ndarray_gpu_util.ts create mode 100644 src/math/webgl/render_ndarray_gpu_util_test.ts create mode 100644 src/math/webgl/reshape_gpu.ts create mode 100644 src/math/webgl/reshape_gpu_test.ts create mode 100644 src/math/webgl/resize_bilinear_gpu.ts create mode 100644 src/math/webgl/resize_bilinear_gpu_test.ts create mode 100644 src/math/webgl/shader_compiler.ts create mode 100644 src/math/webgl/sigmoid_gpu.ts create mode 100644 src/math/webgl/sigmoid_gpu_test.ts create mode 100644 src/math/webgl/step_gpu.ts create mode 100644 src/math/webgl/step_gpu_test.ts create mode 100644 src/math/webgl/tex_util.ts create mode 100644 src/math/webgl/tex_util_test.ts create mode 100644 src/math/webgl/texture_manager.ts create mode 100644 src/math/webgl/trig_gpu.ts create mode 100644 src/math/webgl/trig_gpu_test.ts create mode 100644 src/math/webgl/unaryop_gpu.ts create mode 100644 src/math/webgl/webgl_util.ts create mode 100644 src/operation_emitter.ts create mode 100644 src/ops/add.ts create mode 100644 src/ops/add_test.ts create mode 100644 src/ops/argmax.ts create mode 100644 src/ops/argmax_test.ts create mode 100644 src/ops/argmaxequals.ts create mode 100644 src/ops/argmaxequals_test.ts create mode 100644 src/ops/concat3d.ts create mode 100644 src/ops/concat3d_test.ts create mode 100644 src/ops/convolution.ts create mode 100644 src/ops/convolution_test.ts create mode 100644 src/ops/divide.ts create mode 100644 src/ops/divide_test.ts create mode 100644 src/ops/element_wise_activation.ts create mode 100644 src/ops/element_wise_activation_test.ts create mode 100644 src/ops/element_wise_cost.ts create mode 100644 src/ops/element_wise_cost_test.ts create mode 100644 src/ops/exp.ts create mode 100644 src/ops/exp_test.ts create mode 100644 src/ops/linear_combination.ts create mode 100644 src/ops/linear_combination_test.ts create mode 100644 src/ops/log.ts create mode 100644 src/ops/log_test.ts create mode 100644 src/ops/matmul.ts create mode 100644 src/ops/matmul_test.ts create mode 100644 src/ops/max_pool.ts create mode 100644 src/ops/max_pool_test.ts create mode 100644 src/ops/multiply.ts create mode 100644 src/ops/multiply_test.ts create mode 100644 src/ops/op.ts create mode 100644 src/ops/reduce_sum.ts create mode 100644 src/ops/reduce_sum_test.ts create mode 100644 src/ops/reshape.ts create mode 100644 src/ops/softmax.ts create mode 100644 src/ops/softmax_test.ts create mode 100644 src/ops/split.ts create mode 100644 src/ops/split_test.ts create mode 100644 src/ops/subtract.ts create mode 100644 src/ops/subtract_test.ts create mode 100644 src/optimizer.ts create mode 100644 src/priority_queue.ts create mode 100644 src/priority_queue_test.ts create mode 100644 src/session.ts create mode 100644 src/session_test.ts create mode 100644 src/session_util.ts create mode 100644 src/session_util_test.ts create mode 100644 src/sgd_optimizer.ts create mode 100644 src/tensor_array_map.ts create mode 100644 src/tensor_array_map_test.ts create mode 100644 src/test_util.ts create mode 100644 src/util.ts create mode 100644 src/util_test.ts create mode 100644 tsconfig-doc.json create mode 100644 tsconfig.json create mode 100644 tslint.json diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000..70399bf242 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +node_modules/ +demos/**/*.js +demos/**/*.js.map +coverage/ +bower_components/ diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000000..ea77052f14 --- /dev/null +++ b/.npmignore @@ -0,0 +1,9 @@ +demos/ +dist/demos/ +dist/**/*.js.map +docs/ +scripts/ +src/ +coverage/ +bower_components/ +node_modules/ diff --git a/.npmrc b/.npmrc new file mode 100644 index 0000000000..43c97e719a --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ +package-lock=false diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000000..6d098153f1 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,15 @@ +// Place your settings in this file to overwrite default and user settings. +{ + "search.exclude": { + "**/node_modules": true, + "**/bower_components": true, + "coverage/": true, + "dist/": true + }, + "tslint.configFile": "tslint.json", + "tslint.enable": true, + "tslint.run": "onType", + "editor.tabSize": 2, + "editor.insertSpaces": true, + "files.insertFinalNewline": true +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000000..dd81624820 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,16 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "command": "npm", + "taskName": "lint", + "type": "shell", + "suppressTaskName": true, + "args": [ "run", "lint"], + "problemMatcher": { + "base": "$tslint5", + "fileLocation": "absolute" + } + } + ] +} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000..a9851beff2 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,26 @@ +# How to Contribute + +We'd love to accept your patches and contributions to this project. There are +just a few small guidelines you need to follow. + +## Contributor License Agreement + +Contributions to this project must be accompanied by a Contributor License +Agreement. You (or your employer) retain the copyright to your contribution, +this simply gives us permission to use and redistribute your contributions as +part of the project. Head over to to see +your current agreements on file or to sign a new one. + +You generally only need to submit a CLA once, so if you've already submitted one +(even if it was for a different project), you probably don't need to do it +again. + +## Code reviews + +All submissions, including submissions by project members, require review. We +use GitHub pull requests for this purpose. Consult +[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more +information on using pull requests. + +We require unit tests for most code, instructions for running our unit test +suites are in the documentation. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/README.md b/README.md new file mode 100644 index 0000000000..7eb2ce669a --- /dev/null +++ b/README.md @@ -0,0 +1,100 @@ +--- +layout: page +order: 1 +--- + +# Getting started + +**deeplearn.js** is an open source hardware-accelerated JavaScript library for +machine intelligence. **deeplearn.js** brings performant machine learning +building blocks to the web, allowing you to train neural networks in a browser +or run pre-trained models in inference mode. + +**deeplearn.js** has two APIs, an immediate execution model (think NumPy) and a +deferred execution model mirroring the TensorFlow API. +**deeplearn.js** +was originally developed by the Google Brain PAIR team to build powerful +interactive machine learning tools for the browser, but it can be used for +everything from education, to model understanding, to art projects. + +## Usage + +#### From JavaScript + +Typescript is the preferred language of choice for **deeplearn.js**, however +you can use it with plain JavaScript. + +For this use case, you can load the library directly from Google CDN: + +```html + +``` + +#### From TypeScript + +To build **deeplearn.js** from source, we need to clone the project and prepare +the dev environment: + +```bash +$ git clone https://pair-code.github.com/learnjs +$ cd learnjs +$ npm run prep # Installs node modules and bower components. +``` + +To build a standalone library that can be used directly in the browser using a +` + diff --git a/demos/benchmarks/benchmark-demo.html b/demos/benchmarks/benchmark-demo.html new file mode 100644 index 0000000000..ba981fb1ee --- /dev/null +++ b/demos/benchmarks/benchmark-demo.html @@ -0,0 +1,49 @@ + + + + + + + + + + LearnJS Benchmarks + + + + + + + + + + diff --git a/demos/benchmarks/benchmark.ts b/demos/benchmarks/benchmark.ts new file mode 100644 index 0000000000..c069c3602c --- /dev/null +++ b/demos/benchmarks/benchmark.ts @@ -0,0 +1,40 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export interface BenchmarkRunGroup { + name: string; + // Min and max steps to run the benchmark test over. + min: number; + max: number; + // The size of the step to take between benchmark runs. + stepSize: number; + // A transformation of step to the size passed to the benchmark test. + stepToSizeTransformation?: (step: number) => number; + benchmarkRuns: BenchmarkRun[]; +} + +export class BenchmarkRun { + name: string; + benchmarkTest: BenchmarkTest; + + chartData: ChartData[]; + constructor(name: string, benchmarkTest: BenchmarkTest) { + this.name = name; + this.benchmarkTest = benchmarkTest; + this.chartData = []; + } +} + +export interface BenchmarkTest { (size: number): number; } diff --git a/demos/benchmarks/bundle.js b/demos/benchmarks/bundle.js new file mode 100644 index 0000000000..2a98c40f07 --- /dev/null +++ b/demos/benchmarks/bundle.js @@ -0,0 +1,3788 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o benchmarkRunGroup.max || + this.stopMessages[benchmarkRunGroupIndex]) { + this.stopMessages[benchmarkRunGroupIndex] = false; + runNumbersTable.style.display = ''; + var canvas = this.querySelectorAll('.run-plot')[benchmarkRunGroupIndex]; + canvas.style.display = 'block'; + chart.update(); + var runMessage = this.querySelectorAll('.run-message')[benchmarkRunGroupIndex]; + runMessage.style.display = 'none'; + return; + } + var runNumberRowElement = document.createElement('div'); + runNumberRowElement.className = 'run-numbers-row math-benchmark'; + var rowValues = ['' + step]; + for (var i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) { + var benchmarkRun = benchmarkRunGroup.benchmarkRuns[i]; + var benchmarkTest = benchmarkRun.benchmarkTest; + var size = benchmarkRunGroup.stepToSizeTransformation != null ? + benchmarkRunGroup.stepToSizeTransformation(step) : + step; + var resultString = void 0; + var logString = void 0; + var time = 0; + var success = true; + try { + time = benchmarkTest(size); + resultString = time.toFixed(3) + 'ms'; + logString = resultString; + } + catch (e) { + success = false; + resultString = 'Error'; + logString = e.message; + } + if (time >= 0) { + if (success) { + benchmarkRun.chartData.push({ x: step, y: time }); + } + rowValues.push(resultString); + } + console.log(benchmarkRun.name + '[' + step + ']: ' + logString); + } + runNumbersTable.appendChild(this.buildRunNumbersRow(rowValues)); + step += benchmarkRunGroup.stepSize; + setTimeout(function () { return _this.runBenchmarkSteps(chart, benchmarkRunGroup, benchmarkRunGroupIndex, step); }, 100); + }; + return MathBenchmark; +}(exports.MathBenchmarkPolymer)); +exports.MathBenchmark = MathBenchmark; +document.registerElement(MathBenchmark.prototype.is, MathBenchmark); + +},{"../demo-footer":13,"../demo-header":14,"../polymer-spec":15,"./math-benchmark-run-groups":6}],8:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../../src/math/conv_util"); +var gpgpu_context_1 = require("../../src/math/webgl/gpgpu_context"); +var max_pool_backprop_gpu = require("../../src/math/webgl/max_pool_backprop_gpu"); +var test_util = require("../../src/test_util"); +var util = require("../../src/util"); +var OP_RUNS = 100; +exports.BENCHMARK_TEST = function (size) { + var dyShapeRCD = [size, size, 1]; + var outputDepth = 1; + var fieldSize = 11; + var stride = 1; + var zeroPad = conv_util.computeDefaultPad(dyShapeRCD, fieldSize, stride); + var outputShapeRCD = conv_util.computeOutputShape3D(dyShapeRCD, fieldSize, outputDepth, stride, zeroPad); + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dyShapeRCD, fieldSize, stride, zeroPad)); + var dyTexture = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + var maxPositionsTexture = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + var outputTexture = gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + var dyData = test_util.randomArrayInRange(dyTexShapeRC[0] * dyTexShapeRC[1], -1, 1); + var maxPositionsData = new Float32Array(util.sizeFromShape(dyShapeRCD)); + for (var i = 0; i < maxPositionsData.length; i++) { + maxPositionsData[i] = Math.floor(Math.random() * fieldSize * fieldSize); + } + gpgpu.uploadMatrixToTexture(dyTexture, dyTexShapeRC[0], dyTexShapeRC[1], dyData); + gpgpu.uploadMatrixToTexture(maxPositionsTexture, dyTexShapeRC[0], dyTexShapeRC[1], maxPositionsData); + var start = performance.now(); + for (var i = 0; i < OP_RUNS; i++) { + max_pool_backprop_gpu.maxPoolBackprop(gpgpu, program, dyTexture, maxPositionsTexture, outputTexture, outputTexShapeRC); + } + gpgpu.downloadMatrixFromTexture(outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + var end = performance.now(); + var avgTime = (end - start) / OP_RUNS; + gpgpu.deleteMatrixTexture(dyTexture); + gpgpu.deleteMatrixTexture(maxPositionsTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return avgTime; +}; + +},{"../../src/math/conv_util":17,"../../src/math/webgl/gpgpu_context":24,"../../src/math/webgl/max_pool_backprop_gpu":27,"../../src/test_util":35,"../../src/util":36}],9:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../../src/math/conv_util"); +var gpgpu_context_1 = require("../../src/math/webgl/gpgpu_context"); +var max_pool_gpu = require("../../src/math/webgl/max_pool_gpu"); +var test_util = require("../../src/test_util"); +var OP_RUNS = 100; +exports.MAX_POOL_BENCHMARK_TEST = function (size) { + var inputShapeRCD = [size, size, 1]; + var outputDepth = 1; + var fieldSize = 11; + var stride = 1; + var zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride); + var outputShapeRCD = conv_util.computeOutputShape3D(inputShapeRCD, fieldSize, outputDepth, stride, zeroPad); + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolSource(inputShapeRCD, fieldSize, stride, zeroPad)); + var inputTexture = gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]); + var outputTexture = gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + var inputData = test_util.randomArrayInRange(inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1); + gpgpu.uploadMatrixToTexture(inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData); + var start = performance.now(); + for (var i = 0; i < OP_RUNS; i++) { + max_pool_gpu.maxPoolCommon(gpgpu, program, inputTexture, outputTexture, outputTexShapeRC); + } + gpgpu.downloadMatrixFromTexture(outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + var end = performance.now(); + var avgTime = (end - start) / OP_RUNS; + gpgpu.deleteMatrixTexture(inputTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return avgTime; +}; +exports.MAX_POOL_POSNS_BENCHMARK_TEST = function (size) { + var inputShapeRCD = [size, size, 1]; + var outputDepth = 1; + var fieldSize = 11; + var stride = 1; + var zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride); + var outputShapeRCD = conv_util.computeOutputShape3D(inputShapeRCD, fieldSize, outputDepth, stride, zeroPad); + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(inputShapeRCD, fieldSize, stride, zeroPad)); + var inputTexture = gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]); + var outputTexture = gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + var inputData = test_util.randomArrayInRange(inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1); + gpgpu.uploadMatrixToTexture(inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData); + var start = performance.now(); + for (var i = 0; i < OP_RUNS; i++) { + max_pool_gpu.maxPoolCommon(gpgpu, program, inputTexture, outputTexture, outputTexShapeRC); + } + gpgpu.downloadMatrixFromTexture(outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + var end = performance.now(); + var avgTime = (end - start) / OP_RUNS; + gpgpu.deleteMatrixTexture(inputTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return avgTime; +}; + +},{"../../src/math/conv_util":17,"../../src/math/webgl/gpgpu_context":24,"../../src/math/webgl/max_pool_gpu":28,"../../src/test_util":35}],10:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_cpu_1 = require("../../src/math/math_cpu"); +var ndarray_1 = require("../../src/math/ndarray"); +var OPS_PER_SMALL_RUN = 10; +exports.BENCHMARK_TEST = function (size) { + if (size > 512) { + return -1; + } + var math = new math_cpu_1.NDArrayMathCPU(); + var a = ndarray_1.NDArray.randUniform([size, size], -1, 1); + var b = ndarray_1.NDArray.randUniform([size, size], -1, 1); + var runs = (size < 192) ? OPS_PER_SMALL_RUN : 1; + var start = performance.now(); + for (var i = 0; i < runs; i++) { + math.matMul(a, b); + } + var end = performance.now(); + return (end - start) / runs; +}; + +},{"../../src/math/math_cpu":20,"../../src/math/ndarray":21}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../../src/math/math"); +var ndarray_1 = require("../../src/math/ndarray"); +var gpgpu_context_1 = require("../../src/math/webgl/gpgpu_context"); +var mulmat_gpu = require("../../src/math/webgl/mulmat_gpu"); +var mulmat_packed_gpu = require("../../src/math/webgl/mulmat_packed_gpu"); +var test_util = require("../../src/test_util"); +var OP_RUNS = 100; +exports.BENCHMARK_TEST = function (size) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var aTexture = gpgpu.createMatrixTexture(size, size); + var bTexture = gpgpu.createMatrixTexture(size, size); + var resultTexture = gpgpu.createMatrixTexture(size, size); + var aArr = new ndarray_1.Array2D([size, size], { texture: aTexture, textureShapeRC: [size, size] }); + var bArr = new ndarray_1.Array2D([size, size], { texture: bTexture, textureShapeRC: [size, size] }); + var resArr = new ndarray_1.Array2D([size, size], { texture: resultTexture, textureShapeRC: [size, size] }); + var program = gpgpu.createProgram(mulmat_gpu.getFragmentShader(aArr, bArr, resArr, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.REGULAR)); + var a = test_util.randomArrayInRange(size * size, -1, 1); + var b = test_util.randomArrayInRange(size * size, -1, 1); + gpgpu.uploadMatrixToTexture(aTexture, size, size, a); + gpgpu.uploadMatrixToTexture(bTexture, size, size, b); + var start = performance.now(); + for (var i = 0; i < OP_RUNS; i++) { + mulmat_gpu.multiplyMatrix(gpgpu, program, aTexture, bTexture, resultTexture, [size, size]); + } + var actual = gpgpu.downloadMatrixFromTexture(resultTexture, size, size); + var avgTime = (performance.now() - start) / OP_RUNS; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + var expected = test_util.cpuMultiplyMatrix(a, size, size, b, size, size); + test_util.expectArraysClose(actual, expected, 0.001); + return avgTime; +}; +exports.BENCHMARK_TEST_PACKED = function (size) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(mulmat_packed_gpu.getFragmentShaderSource(size, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.REGULAR)); + var aTexture = gpgpu.createPackedMatrixTexture(size, size); + var bTexture = gpgpu.createPackedMatrixTexture(size, size); + var resultTexture = gpgpu.createPackedMatrixTexture(size, size); + var a = test_util.randomArrayInRange(size * size, -1, 1); + var b = test_util.randomArrayInRange(size * size, -1, 1); + gpgpu.uploadMatrixToPackedTexture(aTexture, size, size, a); + gpgpu.uploadMatrixToPackedTexture(bTexture, size, size, b); + var start = performance.now(); + for (var i = 0; i < OP_RUNS; i++) { + mulmat_packed_gpu.multiplyMatrixPacked(gpgpu, program, aTexture, bTexture, resultTexture, [size, size]); + } + var actual = gpgpu.downloadMatrixFromPackedTexture(resultTexture, size, size); + var avgTime = (performance.now() - start) / OP_RUNS; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + var expected = test_util.cpuMultiplyMatrix(a, size, size, b, size, size); + test_util.expectArraysClose(actual, expected, 0.001); + return avgTime; +}; + +},{"../../src/math/math":19,"../../src/math/ndarray":21,"../../src/math/webgl/gpgpu_context":24,"../../src/math/webgl/mulmat_gpu":29,"../../src/math/webgl/mulmat_packed_gpu":30,"../../src/test_util":35}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("../../src/math/webgl/tex_util"); +var webgl_util = require("../../src/math/webgl/webgl_util"); +var test_util = require("../../src/test_util"); +var OPS_PER_RUN = 100; +exports.BENCHMARK_ENCODE_UNPACKED = function (size) { + var matrix = test_util.randomArrayInRange(size * size, -1, 1); + var channelsPerTexture = webgl_util.getChannelsPerTexture(); + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + var start = performance.now(); + for (var i = 0; i < OPS_PER_RUN; ++i) { + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + } + var end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; +exports.BENCHMARK_ENCODE_PACKED = function (size) { + var matrix = test_util.randomArrayInRange(size * size, -1, 1); + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size)); + var start = performance.now(); + for (var i = 0; i < OPS_PER_RUN; ++i) { + tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA); + } + var end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; +exports.BENCHMARK_DECODE_UNPACKED = function (size) { + var matrix = test_util.randomArrayInRange(size * size, -1, 1); + var channelsPerTexture = webgl_util.getChannelsPerTexture(); + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + var start = performance.now(); + for (var i = 0; i < OPS_PER_RUN; ++i) { + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + } + var end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; +exports.BENCHMARK_DECODE_PACKED = function (size) { + var matrix = test_util.randomArrayInRange(size * size, -1, 1); + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size)); + tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA); + var start = performance.now(); + for (var i = 0; i < OPS_PER_RUN; ++i) { + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, size, size, matrix); + } + var end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; + +},{"../../src/math/webgl/tex_util":33,"../../src/math/webgl/webgl_util":34,"../../src/test_util":35}],13:[function(require,module,exports){ +Polymer({ is: 'demo-footer' }); + +},{}],14:[function(require,module,exports){ +Polymer({ is: 'demo-header' }); + +},{}],15:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function PolymerElement(spec) { + return Polymer.Class(spec); +} +exports.PolymerElement = PolymerElement; + +},{}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":36}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":36}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":36,"./concat3d_util":16,"./copy2d_util":18,"./ndarray":21}],20:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":17,"../util":36,"./concat3d_util":16,"./copy2d_util":18,"./math":19,"./ndarray":21}],21:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":36,"./webgl/webgl_util":34}],22:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":17,"./conv_gpu":23}],23:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":17}],24:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":25,"./tex_util":33,"./webgl_util":34}],25:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":33,"./webgl_util":34}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":24}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":17}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":31}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":19,"./shader_compiler":32}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(sharedDimension, aOrientation, bOrientation) { + var sharedDimensionPacked = Math.ceil(sharedDimension / 2); + var aSample = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + 'center, resultUV.t' : + 'resultUV.t, center'; + var bSample = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + 'resultUV.s, center' : + 'center, resultUV.s'; + var aSwizzle = (aOrientation === math_1.MatrixOrientation.REGULAR) ? ['a.xxzz', 'a.yyww'] : + ['a.xxyy', 'a.zzww']; + var bSwizzle = (bOrientation === math_1.MatrixOrientation.REGULAR) ? ['b.xyxy', 'b.zwzw'] : + ['b.xzxz', 'b.ywyw']; + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n const float sharedDimension = " + sharedDimensionPacked + ".0;\n\n vec4 dot2x2ARowBCol() {\n vec4 result = vec4(0, 0, 0, 0);\n for (float i = 0.0; i < sharedDimension; i += 1.0) {\n float center = (i + 0.5) / sharedDimension;\n vec4 a = texture2D(matrixA, vec2(" + aSample + "));\n vec4 b = texture2D(matrixB, vec2(" + bSample + "));\n result +=\n (" + aSwizzle[0] + " * " + bSwizzle[0] + ") + (" + aSwizzle[1] + " * " + bSwizzle[1] + ");\n }\n return result;\n }\n\n void main() {\n gl_FragColor = dot2x2ARowBCol();\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function multiplyMatrixPacked(gpgpu, multiplyProgram, a, b, result, resultShapeRowCol) { + gpgpu.setOutputPackedMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrixPacked = multiplyMatrixPacked; +function uploadMultiplyMatrixPackedDownload(a, aShapeRowCol, b, bShapeRowCol, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var resultNumRows = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + aShapeRowCol[0] : + aShapeRowCol[1]; + var resultNumCols = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + bShapeRowCol[1] : + bShapeRowCol[0]; + var sharedDimension = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + aShapeRowCol[1] : + aShapeRowCol[0]; + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(sharedDimension, aOrientation, bOrientation)); + var aTexture = gpgpu.createPackedMatrixTexture(aShapeRowCol[0], aShapeRowCol[1]); + var bTexture = gpgpu.createPackedMatrixTexture(bShapeRowCol[0], bShapeRowCol[1]); + var resultTexture = gpgpu.createPackedMatrixTexture(resultNumRows, resultNumCols); + gpgpu.uploadMatrixToPackedTexture(aTexture, aShapeRowCol[0], aShapeRowCol[1], a); + gpgpu.uploadMatrixToPackedTexture(bTexture, bShapeRowCol[0], bShapeRowCol[1], b); + multiplyMatrixPacked(gpgpu, program, aTexture, bTexture, resultTexture, [resultNumRows, resultNumCols]); + var result = gpgpu.downloadMatrixFromPackedTexture(resultTexture, resultNumRows, resultNumCols); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadMultiplyMatrixPackedDownload = uploadMultiplyMatrixPackedDownload; + +},{"../math":19,"./gpgpu_context":24}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":17,"./webgl_util":34}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":36}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":36}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function expectArraysClose(actual, expected, epsilon) { + if (actual.length !== expected.length) { + throw new Error('Matrices have different lengths (' + actual.length + ' vs ' + + expected.length + ').'); + } + for (var i = 0; i < expected.length; ++i) { + var a = actual[i]; + var e = expected[i]; + if (isNaN(a) && isNaN(e)) { + continue; + } + if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon) { + var actualStr = 'actual[' + i + '] === ' + a; + var expectedStr = 'expected[' + i + '] === ' + e; + throw new Error('Arrays differ: ' + actualStr + ', ' + expectedStr); + } + } +} +exports.expectArraysClose = expectArraysClose; +function randomArrayInRange(n, minValue, maxValue) { + var v = new Float32Array(n); + var range = maxValue - minValue; + for (var i = 0; i < n; ++i) { + v[i] = (Math.random() * range) + minValue; + } + return v; +} +exports.randomArrayInRange = randomArrayInRange; +function makeIdentity(n) { + var i = new Float32Array(n * n); + for (var j = 0; j < n; ++j) { + i[(j * n) + j] = 1; + } + return i; +} +exports.makeIdentity = makeIdentity; +function setValue(m, mNumRows, mNumCols, v, row, column) { + if (row >= mNumRows) { + throw new Error('row (' + row + ') must be in [0 ' + mNumRows + '].'); + } + if (column >= mNumCols) { + throw new Error('column (' + column + ') must be in [0 ' + mNumCols + '].'); + } + m[(row * mNumCols) + column] = v; +} +exports.setValue = setValue; +function cpuMultiplyMatrix(a, aRow, aCol, b, bRow, bCol) { + var result = new Float32Array(aRow * bCol); + for (var r = 0; r < aRow; ++r) { + for (var c = 0; c < bCol; ++c) { + var d = 0; + for (var k = 0; k < aCol; ++k) { + d += a[(r * aCol) + k] * b[(k * bCol) + c]; + } + result[(r * bCol) + c] = d; + } + } + return result; +} +exports.cpuMultiplyMatrix = cpuMultiplyMatrix; +function cpuDotProduct(a, b) { + if (a.length !== b.length) { + throw new Error('cpuDotProduct: incompatible vectors.'); + } + var d = 0; + for (var i = 0; i < a.length; ++i) { + d += a[i] * b[i]; + } + return d; +} +exports.cpuDotProduct = cpuDotProduct; + +},{}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[7]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","demos/benchmarks/benchmark.ts","demos/benchmarks/conv_gpu_benchmark.ts","demos/benchmarks/conv_transpose_gpu_benchmark.ts","demos/benchmarks/logsumexp_cpu_benchmark.ts","demos/benchmarks/logsumexp_gpu_benchmark.ts","demos/benchmarks/math-benchmark-run-groups.ts","demos/benchmarks/math-benchmark.ts","demos/benchmarks/max_pool_backprop_gpu_benchmark.ts","demos/benchmarks/max_pool_gpu_benchmark.ts","demos/benchmarks/mulmat_cpu_benchmark.ts","demos/benchmarks/mulmat_gpu_benchmark.ts","demos/benchmarks/tex_util_benchmark.ts","demos/demo-footer.ts","demos/demo-header.ts","demos/polymer-spec.ts","src/math/concat3d_util.ts","src/math/conv_util.ts","src/math/copy2d_util.ts","src/math/math.ts","src/math/math_cpu.ts","src/math/ndarray.ts","src/math/webgl/conv_backprop_gpu.ts","src/math/webgl/conv_gpu.ts","src/math/webgl/gpgpu_context.ts","src/math/webgl/gpgpu_util.ts","src/math/webgl/logsumexp_gpu.ts","src/math/webgl/max_pool_backprop_gpu.ts","src/math/webgl/max_pool_gpu.ts","src/math/webgl/mulmat_gpu.ts","src/math/webgl/mulmat_packed_gpu.ts","src/math/webgl/pool_gpu.ts","src/math/webgl/shader_compiler.ts","src/math/webgl/tex_util.ts","src/math/webgl/webgl_util.ts","src/test_util.ts","src/util.ts"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport interface BenchmarkRunGroup {\n  name: string;\n  // Min and max steps to run the benchmark test over.\n  min: number;\n  max: number;\n  // The size of the step to take between benchmark runs.\n  stepSize: number;\n  // A transformation of step to the size passed to the benchmark test.\n  stepToSizeTransformation?: (step: number) => number;\n  benchmarkRuns: BenchmarkRun[];\n}\n\nexport class BenchmarkRun {\n  name: string;\n  benchmarkTest: BenchmarkTest;\n\n  chartData: ChartData[];\n  constructor(name: string, benchmarkTest: BenchmarkTest) {\n    this.name = name;\n    this.benchmarkTest = benchmarkTest;\n    this.chartData = [];\n  }\n}\n\nexport interface BenchmarkTest { (size: number): number; }\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../../src/math/conv_util';\nimport * as conv_gpu from '../../src/math/webgl/conv_gpu';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const inputShapeRCD: [number, number, number] = [size, size, 1];\n  const outputDepth = 1;\n  const fieldSize = 11;\n  const stride = 1;\n  const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride);\n  const outputShapeRCD: [number, number, number] =\n      conv_util.computeOutputShape3D(\n          inputShapeRCD, fieldSize, outputDepth, stride, zeroPad);\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n  const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD);\n  const weightsTexShapeRC = conv_util.computeWeightsTexShape(\n      inputShapeRCD[2], outputDepth, fieldSize);\n  const biasesTexShapeRC = conv_util.computeBiasesTexShape(outputDepth);\n\n  const hasBias = true;\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(conv_gpu.getFragmentShaderSource(\n      inputShapeRCD, outputDepth, fieldSize, stride, zeroPad, hasBias));\n\n  const inputTexture =\n      gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]);\n  const weightsTexture =\n      gpgpu.createMatrixTexture(weightsTexShapeRC[0], weightsTexShapeRC[1]);\n  const biasesTexture =\n      gpgpu.createMatrixTexture(biasesTexShapeRC[0], biasesTexShapeRC[1]);\n  const outputTexture =\n      gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]);\n\n  const inputData = test_util.randomArrayInRange(\n      inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1);\n  const weightsData = test_util.randomArrayInRange(\n      weightsTexShapeRC[0] * weightsTexShapeRC[1], -1, 1);\n  const biasesData = test_util.randomArrayInRange(\n      biasesTexShapeRC[0] * biasesTexShapeRC[1], -1, 1);\n\n  gpgpu.uploadMatrixToTexture(\n      inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData);\n  gpgpu.uploadMatrixToTexture(\n      weightsTexture, weightsTexShapeRC[0], weightsTexShapeRC[1], weightsData);\n  gpgpu.uploadMatrixToTexture(\n      biasesTexture, biasesTexShapeRC[0], biasesTexShapeRC[1], biasesData);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    conv_gpu.convolve(\n        gpgpu, program, inputTexture, weightsTexture, biasesTexture,\n        outputTexture, outputTexShapeRC);\n  }\n\n  gpgpu.downloadMatrixFromTexture(\n      outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]);\n  const end = performance.now();\n\n  const avgTime = (end - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(inputTexture);\n  gpgpu.deleteMatrixTexture(weightsTexture);\n  gpgpu.deleteMatrixTexture(biasesTexture);\n  gpgpu.deleteMatrixTexture(outputTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../../src/math/conv_util';\nimport * as conv_backprop_gpu from '../../src/math/webgl/conv_backprop_gpu';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const xShapeRCD: [number, number, number] = [size, size, 1];\n  const origOutputDepth = 2;\n  const fieldSize = 11;\n  const origStride = 1;\n  const origPad = 1;\n\n  const gpgpu = new GPGPUContext();\n  gpgpu.enableAutomaticDebugValidation(true);\n  const origInputDepth = xShapeRCD[2];\n  const src = conv_backprop_gpu.getFragmentShaderConvTransposeSource(\n      xShapeRCD, fieldSize, origInputDepth, origStride, origPad, false);\n  const program = gpgpu.createProgram(src);\n\n  // Upload x.\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]);\n  const xData =\n      test_util.randomArrayInRange(xTexShapeRC[0] * xTexShapeRC[1], -1, 1);\n  gpgpu.uploadMatrixToTexture(xTex, xTexShapeRC[0], xTexShapeRC[1], xData);\n\n  // Upload weights.\n  const wTexShapeRC = conv_util.computeWeightsTexShape(\n      origInputDepth, origOutputDepth, fieldSize);\n  const wData =\n      test_util.randomArrayInRange(wTexShapeRC[0] * wTexShapeRC[1], -1, 1);\n  const wTex = gpgpu.createMatrixTexture(wTexShapeRC[0], wTexShapeRC[1]);\n  gpgpu.uploadMatrixToTexture(wTex, wTexShapeRC[0], wTexShapeRC[1], wData);\n\n  // Figure out the output shape by dilating the input.\n  const dilatedRC =\n      conv_util.computeDilatedRC([xShapeRCD[0], xShapeRCD[1]], origStride);\n  const pad = fieldSize - 1 - origPad;\n  const resultShapeRCD = conv_util.computeOutputShape3D(\n      [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth,\n      1, pad);\n\n  const resultTexRC = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n  const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    conv_backprop_gpu.convTranspose(\n        gpgpu, program, xTex, wTex, null, resultTex, resultTexRC);\n  }\n\n  const y = gpgpu.downloadMatrixFromTexture(\n      resultTex, resultTexRC[0], resultTexRC[1]);\n\n  const end = performance.now();\n\n  const avgTime = (end - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(resultTex);\n  gpgpu.deleteMatrixTexture(xTex);\n  gpgpu.deleteMatrixTexture(wTex);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMathCPU} from '../../src/math/math_cpu';\nimport {Array2D, NDArray} from '../../src/math/ndarray';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OPS_PER_RUN = 10;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const math = new NDArrayMathCPU();\n  const a = NDArray.randUniform<Array2D>([size, size], -1, 1);\n  const start = performance.now();\n  for (let i = 0; i < OPS_PER_RUN; i++) {\n    math.logSumExp(a);\n  }\n  const end = performance.now();\n  return (end - start) / OPS_PER_RUN;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as logsumexp_gpu from '../../src/math/webgl/logsumexp_gpu';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const gpgpu = new GPGPUContext();\n\n  const program =\n      gpgpu.createProgram(logsumexp_gpu.getFragmentShaderSource(size, size));\n\n  const aTexture = gpgpu.createMatrixTexture(size, size);\n  const resultTexture = gpgpu.createMatrixTexture(size, size);\n\n  const a = test_util.randomArrayInRange(size * size, -1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, size, size, a);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    logsumexp_gpu.logSumExp(\n        gpgpu, program, aTexture, size, size, resultTexture);\n  }\n\n  gpgpu.downloadMatrixFromTexture(resultTexture, size, size);\n  const avgTime = (performance.now() - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {BenchmarkRun, BenchmarkRunGroup} from './benchmark';\nimport * as conv_gpu_benchmark from './conv_gpu_benchmark';\nimport * as conv_transpose_gpu_benchmark from './conv_transpose_gpu_benchmark';\nimport * as logsumexp_cpu_benchmark from './logsumexp_cpu_benchmark';\nimport * as logsumexp_gpu_benchmark from './logsumexp_gpu_benchmark';\nimport * as max_pool_backprop_gpu_benchmark from './max_pool_backprop_gpu_benchmark';\nimport * as max_pool_gpu_benchmark from './max_pool_gpu_benchmark';\nimport * as mulmat_cpu_benchmark from './mulmat_cpu_benchmark';\nimport * as mulmat_gpu_benchmark from './mulmat_gpu_benchmark';\nimport * as tex_util_benchmark from './tex_util_benchmark';\n\nexport const BENCHMARK_RUN_GROUPS: BenchmarkRunGroup[] = [\n  {\n    name: 'Texture encoding / decoding (unpacked vs packed)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [\n      new BenchmarkRun(\n          'encode_unpacked', tex_util_benchmark.BENCHMARK_ENCODE_UNPACKED),\n      new BenchmarkRun(\n          'encode_packed', tex_util_benchmark.BENCHMARK_ENCODE_PACKED),\n      new BenchmarkRun(\n          'decode_unpacked', tex_util_benchmark.BENCHMARK_DECODE_UNPACKED),\n      new BenchmarkRun(\n          'decode_packed', tex_util_benchmark.BENCHMARK_DECODE_PACKED)\n    ]\n  },\n  {\n    name: 'Matrix Multiplication (CPU vs GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [\n      new BenchmarkRun('mulmat_gpu', mulmat_gpu_benchmark.BENCHMARK_TEST),\n      new BenchmarkRun(\n          'mulmat_packed_gpu', mulmat_gpu_benchmark.BENCHMARK_TEST_PACKED),\n      new BenchmarkRun('mulmat_cpu', mulmat_cpu_benchmark.BENCHMARK_TEST)\n    ],\n  },\n  {\n    name: 'LogSumExp (CPU vs GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [\n      new BenchmarkRun('logsumexp_gpu', logsumexp_gpu_benchmark.BENCHMARK_TEST),\n      new BenchmarkRun('logsumexp_cpu', logsumexp_cpu_benchmark.BENCHMARK_TEST)\n    ],\n  },\n  {\n    name: 'Convolution (GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [new BenchmarkRun(\n        'd1=1, d2=1, f=11, s=1', conv_gpu_benchmark.BENCHMARK_TEST)],\n  },\n  {\n    name: 'Convolution Transposed (GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [new BenchmarkRun(\n        'd1=1, d2=1, f=11, s=1', conv_transpose_gpu_benchmark.BENCHMARK_TEST)],\n  },\n  {\n    name: 'Max pool (GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [new BenchmarkRun(\n        'd1=1, d2=1, f=11, s=1',\n        max_pool_gpu_benchmark.MAX_POOL_BENCHMARK_TEST)],\n  },\n  {\n    name: 'Max pool positions (GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [new BenchmarkRun(\n        'd1=1, d2=1, f=11, s=1',\n        max_pool_gpu_benchmark.MAX_POOL_POSNS_BENCHMARK_TEST)],\n  },\n  {\n    name: 'Max pool backprop (GPU)',\n    min: 0,\n    max: 1024,\n    stepSize: 64,\n    stepToSizeTransformation: (step: number) => Math.max(1, step),\n    benchmarkRuns: [new BenchmarkRun(\n        'd1=1, d2=1, f=11, s=1',\n        max_pool_backprop_gpu_benchmark.BENCHMARK_TEST)],\n  }\n];\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport '../demo-header';\nimport '../demo-footer';\n\n// tslint:disable-next-line:no-unused-variable\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\nimport {BenchmarkRunGroup} from './benchmark';\n\nimport {BENCHMARK_RUN_GROUPS} from './math-benchmark-run-groups';\n\n// tslint:disable-next-line:variable-name\nexport let MathBenchmarkPolymer = PolymerElement(\n    {is: 'math-benchmark', properties: {benchmarkRunGroupNames: Array}});\n\nexport class MathBenchmark extends MathBenchmarkPolymer {\n  // Polymer properties.\n  private benchmarkRunGroupNames: string[];\n  private stopMessages: boolean[];\n\n  ready() {\n    // Set up the benchmarks UI.\n    const benchmarkRunGroupNames: string[] = [];\n    this.stopMessages = [];\n    for (let i = 0; i < BENCHMARK_RUN_GROUPS.length; i++) {\n      benchmarkRunGroupNames.push(BENCHMARK_RUN_GROUPS[i].name);\n      this.stopMessages.push(false);\n    }\n    this.benchmarkRunGroupNames = benchmarkRunGroupNames;\n\n    // In a setTimeout to let the UI update before we add event listeners.\n    setTimeout(() => {\n      const runButtons = this.querySelectorAll('.run-test');\n      const stopButtons = this.querySelectorAll('.run-stop');\n      for (let i = 0; i < runButtons.length; i++) {\n        runButtons[i].addEventListener('click', () => {\n          this.runBenchmarkGroup(i);\n        });\n        stopButtons[i].addEventListener('click', () => {\n          this.stopMessages[i] = true;\n        });\n      }\n    }, 0);\n  }\n\n  private runBenchmarkGroup(benchmarkRunGroupIndex: number) {\n    const benchmarkRunGroup = BENCHMARK_RUN_GROUPS[benchmarkRunGroupIndex];\n\n    const canvas = this.querySelectorAll('.run-plot')[benchmarkRunGroupIndex] as\n        HTMLCanvasElement;\n    const context = canvas.getContext('2d') as CanvasRenderingContext2D;\n\n    const datasets: ChartDataSets[] = [];\n    for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) {\n      const hue = Math.floor(360 * i / benchmarkRunGroup.benchmarkRuns.length);\n      datasets.push({\n        data: benchmarkRunGroup.benchmarkRuns[i].chartData,\n        fill: false,\n        label: benchmarkRunGroup.benchmarkRuns[i].name,\n        borderColor: 'hsl(' + hue + ', 100%, 40%)',\n        backgroundColor: 'hsl(' + hue + ', 100%, 70%)',\n        pointRadius: 0,\n        pointHitRadius: 5,\n        borderWidth: 1,\n        lineTension: 0\n      });\n    }\n\n    const chart = new Chart(context, {\n      type: 'line',\n      data: {datasets},\n      options: {\n        animation: {duration: 0},\n        responsive: false,\n        scales: {\n          xAxes: [{\n            type: 'linear',\n            position: 'bottom',\n            ticks: {\n              min: benchmarkRunGroup.min,\n              max: benchmarkRunGroup.max,\n              stepSize: benchmarkRunGroup.stepSize,\n              callback: (label: string) => {\n                return benchmarkRunGroup.stepToSizeTransformation != null ?\n                    benchmarkRunGroup.stepToSizeTransformation(+label) :\n                    +label;\n              }\n              // tslint:disable-next-line:no-any\n            } as any  // Note: the typings for this are incorrect, cast as any.\n          }],\n          yAxes: [{\n            ticks: {\n              callback: (label, index, labels) => {\n                return label + 'ms';\n              }\n            },\n          }]\n        },\n        tooltips: {mode: 'label'},\n        title: {text: benchmarkRunGroup.name}\n      }\n    });\n    canvas.style.display = 'none';\n\n    const runMessage =\n        this.querySelectorAll('.run-message')[benchmarkRunGroupIndex] as\n        HTMLElement;\n    runMessage.style.display = 'block';\n\n    const runNumbersTable =\n        this.querySelectorAll('.run-numbers-table')[benchmarkRunGroupIndex] as\n        HTMLElement;\n    runNumbersTable.innerHTML = '';\n    runNumbersTable.style.display = 'none';\n\n    // Set up the header for the table.\n    const headers = ['size'];\n    for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) {\n      headers.push(benchmarkRunGroup.benchmarkRuns[i].name);\n    }\n    runNumbersTable.appendChild(this.buildRunNumbersRow(headers));\n\n    this.runBenchmarkSteps(\n        chart, benchmarkRunGroup, benchmarkRunGroupIndex,\n        benchmarkRunGroup.min);\n  }\n\n  private buildRunNumbersRow(values: string[]) {\n    const runNumberRowElement = document.createElement('div');\n    runNumberRowElement.className = 'run-numbers-row math-benchmark';\n\n    for (let i = 0; i < values.length; i++) {\n      const runNumberCellElement = document.createElement('div');\n      runNumberCellElement.className = 'run-numbers-cell math-benchmark';\n      runNumberCellElement.innerText = values[i];\n      runNumberRowElement.appendChild(runNumberCellElement);\n    }\n    return runNumberRowElement;\n  }\n\n  private runBenchmarkSteps(\n      chart: Chart, benchmarkRunGroup: BenchmarkRunGroup,\n      benchmarkRunGroupIndex: number, step: number) {\n    const runNumbersTable =\n        this.querySelectorAll('.run-numbers-table')[benchmarkRunGroupIndex] as\n        HTMLElement;\n    if (step > benchmarkRunGroup.max ||\n        this.stopMessages[benchmarkRunGroupIndex]) {\n      this.stopMessages[benchmarkRunGroupIndex] = false;\n\n      runNumbersTable.style.display = '';\n\n      const canvas =\n          this.querySelectorAll('.run-plot')[benchmarkRunGroupIndex] as\n          HTMLCanvasElement;\n      canvas.style.display = 'block';\n      chart.update();\n\n      const runMessage =\n          this.querySelectorAll('.run-message')[benchmarkRunGroupIndex] as\n          HTMLElement;\n      runMessage.style.display = 'none';\n\n      return;\n    }\n\n    const runNumberRowElement = document.createElement('div');\n    runNumberRowElement.className = 'run-numbers-row math-benchmark';\n\n    const rowValues: string[] = ['' + step];\n    for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) {\n      const benchmarkRun = benchmarkRunGroup.benchmarkRuns[i];\n      const benchmarkTest = benchmarkRun.benchmarkTest;\n\n      const size = benchmarkRunGroup.stepToSizeTransformation != null ?\n          benchmarkRunGroup.stepToSizeTransformation(step) :\n          step;\n\n      let resultString: string;\n      let logString: string;\n      let time = 0;\n      let success = true;\n\n      try {\n        time = benchmarkTest(size);\n        resultString = time.toFixed(3) + 'ms';\n        logString = resultString;\n      } catch (e) {\n        success = false;\n        resultString = 'Error';\n        logString = e.message;\n      }\n\n      if (time >= 0) {\n        if (success) {\n          benchmarkRun.chartData.push({x: step, y: time});\n        }\n        rowValues.push(resultString);\n      }\n      console.log(benchmarkRun.name + '[' + step + ']: ' + logString);\n    }\n    runNumbersTable.appendChild(this.buildRunNumbersRow(rowValues));\n\n    step += benchmarkRunGroup.stepSize;\n    // Allow the UI to update.\n    setTimeout(\n        () => this.runBenchmarkSteps(\n            chart, benchmarkRunGroup, benchmarkRunGroupIndex, step),\n        100);\n  }\n}\ndocument.registerElement(MathBenchmark.prototype.is, MathBenchmark);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../../src/math/conv_util';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as max_pool_backprop_gpu from '../../src/math/webgl/max_pool_backprop_gpu';\nimport * as test_util from '../../src/test_util';\nimport * as util from '../../src/util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const dyShapeRCD: [number, number, number] = [size, size, 1];\n  const outputDepth = 1;\n  const fieldSize = 11;\n  const stride = 1;\n  const zeroPad = conv_util.computeDefaultPad(dyShapeRCD, fieldSize, stride);\n  const outputShapeRCD: [number, number, number] =\n      conv_util.computeOutputShape3D(\n          dyShapeRCD, fieldSize, outputDepth, stride, zeroPad);\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD);\n\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(\n      max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(\n          dyShapeRCD, fieldSize, stride, zeroPad));\n\n  const dyTexture = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]);\n  const maxPositionsTexture =\n      gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]);\n  const outputTexture =\n      gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]);\n\n  const dyData =\n      test_util.randomArrayInRange(dyTexShapeRC[0] * dyTexShapeRC[1], -1, 1);\n  const maxPositionsData = new Float32Array(util.sizeFromShape(dyShapeRCD));\n  for (let i = 0; i < maxPositionsData.length; i++) {\n    maxPositionsData[i] = Math.floor(Math.random() * fieldSize * fieldSize);\n  }\n\n  gpgpu.uploadMatrixToTexture(\n      dyTexture, dyTexShapeRC[0], dyTexShapeRC[1], dyData);\n  gpgpu.uploadMatrixToTexture(\n      maxPositionsTexture, dyTexShapeRC[0], dyTexShapeRC[1], maxPositionsData);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    max_pool_backprop_gpu.maxPoolBackprop(\n        gpgpu, program, dyTexture, maxPositionsTexture, outputTexture,\n        outputTexShapeRC);\n  }\n\n  gpgpu.downloadMatrixFromTexture(\n      outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]);\n  const end = performance.now();\n\n  const avgTime = (end - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(dyTexture);\n  gpgpu.deleteMatrixTexture(maxPositionsTexture);\n  gpgpu.deleteMatrixTexture(outputTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../../src/math/conv_util';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as max_pool_gpu from '../../src/math/webgl/max_pool_gpu';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const MAX_POOL_BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const inputShapeRCD: [number, number, number] = [size, size, 1];\n  const outputDepth = 1;\n  const fieldSize = 11;\n  const stride = 1;\n  const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride);\n  const outputShapeRCD: [number, number, number] =\n      conv_util.computeOutputShape3D(\n          inputShapeRCD, fieldSize, outputDepth, stride, zeroPad);\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n  const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD);\n\n  const gpgpu = new GPGPUContext();\n  const program =\n      gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolSource(\n          inputShapeRCD, fieldSize, stride, zeroPad));\n\n  const inputTexture =\n      gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]);\n  const outputTexture =\n      gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]);\n\n  const inputData = test_util.randomArrayInRange(\n      inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1);\n\n  gpgpu.uploadMatrixToTexture(\n      inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    max_pool_gpu.maxPoolCommon(\n        gpgpu, program, inputTexture, outputTexture, outputTexShapeRC);\n  }\n\n  gpgpu.downloadMatrixFromTexture(\n      outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]);\n  const end = performance.now();\n\n  const avgTime = (end - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(inputTexture);\n  gpgpu.deleteMatrixTexture(outputTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};\n\nexport const MAX_POOL_POSNS_BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const inputShapeRCD: [number, number, number] = [size, size, 1];\n  const outputDepth = 1;\n  const fieldSize = 11;\n  const stride = 1;\n  const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride);\n  const outputShapeRCD: [number, number, number] =\n      conv_util.computeOutputShape3D(\n          inputShapeRCD, fieldSize, outputDepth, stride, zeroPad);\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n  const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD);\n\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(\n          inputShapeRCD, fieldSize, stride, zeroPad));\n\n  const inputTexture =\n      gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]);\n  const outputTexture =\n      gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]);\n\n  const inputData = test_util.randomArrayInRange(\n      inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1);\n\n  gpgpu.uploadMatrixToTexture(\n      inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    max_pool_gpu.maxPoolCommon(\n        gpgpu, program, inputTexture, outputTexture, outputTexShapeRC);\n  }\n\n  gpgpu.downloadMatrixFromTexture(\n      outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]);\n  const end = performance.now();\n\n  const avgTime = (end - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(inputTexture);\n  gpgpu.deleteMatrixTexture(outputTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return avgTime;\n};","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMathCPU} from '../../src/math/math_cpu';\nimport {Array2D, NDArray} from '../../src/math/ndarray';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OPS_PER_SMALL_RUN = 10;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  if (size > 512) {\n    return -1;\n  }\n  const math = new NDArrayMathCPU();\n  const a = NDArray.randUniform<Array2D>([size, size], -1, 1);\n  const b = NDArray.randUniform<Array2D>([size, size], -1, 1);\n  const runs = (size < 192) ? OPS_PER_SMALL_RUN : 1;\n  const start = performance.now();\n  for (let i = 0; i < runs; i++) {\n    math.matMul(a, b);\n  }\n  const end = performance.now();\n  return (end - start) / runs;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../../src/math/math';\nimport {Array2D} from '../../src/math/ndarray';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as mulmat_gpu from '../../src/math/webgl/mulmat_gpu';\nimport * as mulmat_packed_gpu from '../../src/math/webgl/mulmat_packed_gpu';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OP_RUNS = 100;\n\nexport const BENCHMARK_TEST: BenchmarkTest = (size: number) => {\n  const gpgpu = new GPGPUContext();\n  const aTexture = gpgpu.createMatrixTexture(size, size);\n  const bTexture = gpgpu.createMatrixTexture(size, size);\n  const resultTexture = gpgpu.createMatrixTexture(size, size);\n\n  const aArr = new Array2D(\n      [size, size], {texture: aTexture, textureShapeRC: [size, size]});\n  const bArr = new Array2D(\n      [size, size], {texture: bTexture, textureShapeRC: [size, size]});\n  const resArr = new Array2D(\n      [size, size], {texture: resultTexture, textureShapeRC: [size, size]});\n  const program = gpgpu.createProgram(mulmat_gpu.getFragmentShader(\n      aArr, bArr, resArr, MatrixOrientation.REGULAR,\n      MatrixOrientation.REGULAR));\n\n  const a = test_util.randomArrayInRange(size * size, -1, 1);\n  const b = test_util.randomArrayInRange(size * size, -1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, size, size, a);\n  gpgpu.uploadMatrixToTexture(bTexture, size, size, b);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    mulmat_gpu.multiplyMatrix(\n        gpgpu, program, aTexture, bTexture, resultTexture, [size, size]);\n  }\n\n  const actual = gpgpu.downloadMatrixFromTexture(resultTexture, size, size);\n  const avgTime = (performance.now() - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  const expected = test_util.cpuMultiplyMatrix(a, size, size, b, size, size);\n  test_util.expectArraysClose(actual, expected, 0.001);\n  return avgTime;\n};\n\nexport const BENCHMARK_TEST_PACKED: BenchmarkTest = (size: number) => {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(mulmat_packed_gpu.getFragmentShaderSource(\n          size, MatrixOrientation.REGULAR, MatrixOrientation.REGULAR));\n\n  const aTexture = gpgpu.createPackedMatrixTexture(size, size);\n  const bTexture = gpgpu.createPackedMatrixTexture(size, size);\n  const resultTexture = gpgpu.createPackedMatrixTexture(size, size);\n\n  const a = test_util.randomArrayInRange(size * size, -1, 1);\n  const b = test_util.randomArrayInRange(size * size, -1, 1);\n  gpgpu.uploadMatrixToPackedTexture(aTexture, size, size, a);\n  gpgpu.uploadMatrixToPackedTexture(bTexture, size, size, b);\n\n  const start = performance.now();\n  for (let i = 0; i < OP_RUNS; i++) {\n    mulmat_packed_gpu.multiplyMatrixPacked(\n        gpgpu, program, aTexture, bTexture, resultTexture, [size, size]);\n  }\n\n  const actual =\n      gpgpu.downloadMatrixFromPackedTexture(resultTexture, size, size);\n  const avgTime = (performance.now() - start) / OP_RUNS;\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  const expected = test_util.cpuMultiplyMatrix(a, size, size, b, size, size);\n  test_util.expectArraysClose(actual, expected, 0.001);\n  return avgTime;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from '../../src/math/webgl/gpgpu_util';\nimport * as tex_util from '../../src/math/webgl/tex_util';\nimport * as webgl_util from '../../src/math/webgl/webgl_util';\nimport * as test_util from '../../src/test_util';\n\nimport {BenchmarkTest} from './benchmark';\n\nconst OPS_PER_RUN = 100;\n\nexport const BENCHMARK_ENCODE_UNPACKED: BenchmarkTest = (size: number) => {\n  const matrix = test_util.randomArrayInRange(size * size, -1, 1);\n  const channelsPerTexture = webgl_util.getChannelsPerTexture();\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  const start = performance.now();\n  for (let i = 0; i < OPS_PER_RUN; ++i) {\n    tex_util.encodeMatrixToUnpackedArray(\n        matrix, unpackedArray, channelsPerTexture);\n  }\n  const end = performance.now();\n  return (end - start) / OPS_PER_RUN;\n};\n\nexport const BENCHMARK_ENCODE_PACKED: BenchmarkTest = (size: number) => {\n  const matrix = test_util.randomArrayInRange(size * size, -1, 1);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size));\n  const start = performance.now();\n  for (let i = 0; i < OPS_PER_RUN; ++i) {\n    tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA);\n  }\n  const end = performance.now();\n  return (end - start) / OPS_PER_RUN;\n};\n\nexport const BENCHMARK_DECODE_UNPACKED: BenchmarkTest = (size: number) => {\n  const matrix = test_util.randomArrayInRange(size * size, -1, 1);\n  const channelsPerTexture = webgl_util.getChannelsPerTexture();\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n  const start = performance.now();\n  for (let i = 0; i < OPS_PER_RUN; ++i) {\n    tex_util.decodeMatrixFromUnpackedArray(\n        unpackedArray, matrix, channelsPerTexture);\n  }\n  const end = performance.now();\n  return (end - start) / OPS_PER_RUN;\n};\n\nexport const BENCHMARK_DECODE_PACKED: BenchmarkTest = (size: number) => {\n  const matrix = test_util.randomArrayInRange(size * size, -1, 1);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size));\n  tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA);\n  const start = performance.now();\n  for (let i = 0; i < OPS_PER_RUN; ++i) {\n    tex_util.decodeMatrixFromPackedRGBA(packedRGBA, size, size, matrix);\n  }\n  const end = performance.now();\n  return (end - start) / OPS_PER_RUN;\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-footer'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-header'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * @fileoverview\n *\n * Defines an interface for creating Polymer elements in Typescript with the\n * correct typings. A Polymer element should be defined like this:\n *\n * ```\n * let MyElementPolymer = PolymerElement({\n *   is: 'my-polymer-element',\n *   properties: {\n *     foo: string,\n *     bar: Array\n *   }\n * });\n *\n * class MyElement extends MyElementPolymer {\n *   foo: string;\n *   bar: number[];\n *\n *   ready() {\n *     console.log('MyElement initialized!');\n *   }\n * }\n *\n * document.registerElement(MyElement.prototype.is, MyElement);\n * ```\n */\n\nexport type Spec = {\n  is: string; properties: {\n    [key: string]: (Function|{\n      // tslint:disable-next-line:no-any\n      type: Function, value?: any;\n      reflectToAttribute?: boolean;\n      readonly?: boolean;\n      notify?: boolean;\n      computed?: string;\n      observer?: string;\n    })\n  };\n  observers?: string[];\n};\n\nexport function PolymerElement(spec: Spec) {\n  // tslint:disable-next-line:no-any\n  return Polymer.Class(spec as any) as {new (): PolymerHTMLElement};\n}\n\nexport interface PolymerHTMLElement extends HTMLElement, polymer.Base {}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function assertConcat3DShapesMatch(\n    x1Shape: number[], x2Shape: number[], axis: number,\n    errorMessagePrefix = '') {\n  util.assert(\n      x1Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.');\n  util.assert(\n      x2Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.');\n\n  util.assert(\n      axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.');\n\n  for (let i = 0; i < 3; i++) {\n    util.assert(\n        (i === axis) || (x1Shape[i] === x2Shape[i]),\n        errorMessagePrefix +\n            `Shape (${x1Shape}) does not match (${x2Shape}) along ` +\n            `non-concatenated axis.`);\n  }\n}\n\nexport function computeConcat3DOutputShape(\n    x1Shape: number[], x2Shape: number[],\n    axis: number): [number, number, number] {\n  util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.');\n  util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.');\n\n  const outputShape = x1Shape.slice();\n  outputShape[axis] += x2Shape[axis];\n  return outputShape as [number, number, number];\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function computeOutputShape3D(\n    inputShapeRowColDepth: [number, number, number], fieldSize: number,\n    depth: number, stride: number, zeroPad?: number): [number, number, number] {\n  if (zeroPad == null) {\n    zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride);\n  }\n  const inputRows = inputShapeRowColDepth[0];\n  const inputCols = inputShapeRowColDepth[1];\n  const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputRows),\n      `The output # of rows (${outputRows}) must be an integer. Change the ` +\n          `stride and/or zero pad parameters`);\n\n  const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputCols),\n      `The output # of columns (${outputCols}) must be an integer. Change ` +\n          `the stride and/or zero pad parameters`);\n\n  return [outputRows, outputCols, depth];\n}\n\nexport function computeDefaultPad(\n    inputShape: [number, number, number], fieldSize: number,\n    stride: number): number {\n  return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2);\n}\n\nexport function computeTexShapeFrom3D(\n    shapeRowColDepth: [number, number, number]): [number, number] {\n  return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]];\n}\n\nexport function computeWeightsShape4D(\n    inputDepth: number, outputDepth: number,\n    fSize: number): [number, number, number, number] {\n  return [fSize, fSize, inputDepth, outputDepth];\n}\n\nexport function computeWeightsTexShape(\n    inputDepth: number, outputDepth: number,\n    fieldSize: number): [number, number] {\n  return [fieldSize * fieldSize * inputDepth, outputDepth];\n}\n\nexport function computeBiasesTexShape(outputDepth: number): [number, number] {\n  return [1, outputDepth];\n}\n\nexport function computeDilatedRC(\n    rc: [number, number], origStride: number): [number, number] {\n  const rowsDilated = (rc[0] - 1) * origStride + 1;\n  const colsDilated = (rc[1] - 1) * origStride + 1;\n  return [rowsDilated, colsDilated];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function validateShapes(\n    sourceSize: [number, number], destSize: [number, number]) {\n  const srcArea = sourceSize[0] * sourceSize[1];\n  const dstArea = destSize[0] * destSize[1];\n  if (srcArea !== dstArea) {\n    const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']';\n    const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']';\n    throw new Error(\n        'copy2D shapes have different areas:\\n  sourceSize ' + srcStr +\n        ', area ' + srcArea + '\\n  destSize ' + dstStr + ', area ' + dstArea);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2d_util from './copy2d_util';\n\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport type ScopeResult = NDArray[]|NDArray|void;\n\nexport abstract class NDArrayMath {\n  private ndarrayScopes: NDArray[][] = [];\n  private activeScope: NDArray[];\n\n  private ndarraysToKeep: NDArray[][] = [];\n  private activeScopeNDArraysToKeep: NDArray[] = [];\n\n  /**\n   * @param safeMode In safe mode, you must use math operations inside\n   * a math.scope() which will automatically clean up intermediate NDArrays.\n   */\n  constructor(private safeMode: boolean) {}\n\n  /**\n   * Create a new math scope. Put chained math operations inside a scope\n   * function closure so that the library automatically cleans up NDArrays\n   * from intermediate math operations. You must create a scope in safe mode\n   * to call math operations. If a result is returned from the scope, it will\n   * also be tracked, which means there must be yet another wrapping scope.\n   * @param scopeFn The function to execute with chained math operations.\n   */\n  scope<T extends ScopeResult>(\n      scopeFn:\n          (keep: <T1 extends NDArray>(ndarray: T1) => T1,\n           track: <T2 extends NDArray>(ndarray: T2) => T2) => T) {\n    this.startScope();\n\n    const keepFn = <T extends NDArray>(ndarray: T): T => this.keep(ndarray);\n    const trackFn = <T extends NDArray>(ndarray: T): T => this.track(ndarray);\n    const result = scopeFn(keepFn, trackFn);\n\n    this.endScope(result);\n\n    return result;\n  }\n\n  /**\n   * Start a scope. Use this with endScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  startScope() {\n    const newScope: NDArray[] = [];\n    this.ndarrayScopes.push(newScope);\n    this.activeScope = newScope;\n\n    const newNDArraysToKeep: NDArray[] = [];\n    this.ndarraysToKeep.push(newNDArraysToKeep);\n    this.activeScopeNDArraysToKeep = newNDArraysToKeep;\n  }\n\n  /**\n   * End a scope. Use this with startScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  endScope(result: ScopeResult) {\n    // Dispose the current scope.\n    for (let i = 0; i < this.activeScope.length; i++) {\n      const ndarray = this.activeScope[i];\n\n      if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) ||\n          (result != null && result instanceof NDArray &&\n           ndarray.getData() === (result as NDArray).getData())) {\n        continue;\n      }\n      ndarray.dispose();\n    }\n\n    // Pop the current scope.\n    this.ndarrayScopes.pop();\n    this.activeScope = this.ndarrayScopes.length === 0 ?\n        null! :\n        this.ndarrayScopes[this.ndarrayScopes.length - 1];\n\n    // Track the current result in the parent scope.\n    if (result instanceof NDArray &&\n        !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) {\n      this.track(result);\n    } else if (Array.isArray(result)) {\n      result.forEach(r => {\n        if (r instanceof NDArray &&\n            !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) {\n          this.track(r);\n        }\n      });\n    }\n\n    this.ndarraysToKeep.pop();\n    this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ?\n        null! :\n        this.ndarraysToKeep[this.ndarraysToKeep.length - 1];\n  }\n\n  private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) {\n    for (let i = 0; i < ndarrayList.length; i++) {\n      if (ndarrayList[i].getData() === ndarray.getData()) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Keeps an NDArray in the current scope from being disposed automatically.\n   * @param result The NDArray to keep from being disposed.\n   */\n  keep<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScopeNDArraysToKeep.push(result);\n    return result;\n  }\n\n  /**\n   * Tracks an NDArray in the current scope to be automatically cleaned up when\n   * the current scope ends, and returns the value.\n   * @param result The NDArray to track in the current scope.\n   */\n  track<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScope.push(result);\n    return result;\n  }\n\n  /**\n   * Computes the dot product of two matrices, A * B. These must be matrices,\n   * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct\n   * in other cases.\n   * @param a First matrix in dot product operation.\n   * @param b Second matrix in dot product operation.\n   * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will\n   * compute A^T * B.\n   * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will\n   * compute A * B^T.\n   */\n  matMul(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const innerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const innerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1];\n\n    util.assert(\n        a.rank === 2 && b.rank === 2,\n        `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` +\n            `and ${b.rank}.`);\n\n    util.assert(\n        innerShapeA === innerShapeB,\n        `Error in matMul: inner shapes (${innerShapeA}) and (` +\n            `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` +\n            `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` +\n            ` and ${MatrixOrientation[bOrientation]} must match.`);\n\n    return this.track(this.matMulInternal(a, b, aOrientation, bOrientation));\n  }\n  protected abstract matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D;\n\n  /**\n   * Computes the dot product of a vector and a matrix, v * B.\n   * @param v The vector in dot product operation.\n   * @param matrix The matrix in dot product operation.\n   */\n  vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: first input must be rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: second input must be rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[0],\n        `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `rank ${matrix.rank}.`);\n\n    return this.matMul(v.as2D(1, v.size), matrix).as1D();\n  }\n\n  /**\n   * Computes the dot product of a matrix and vector, A * v.\n   * @param matrix The matrix in dot product operation.\n   * @param v The vector in dot product operation.\n   */\n  matrixTimesVector(matrix: Array2D, v: Array1D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: second input must rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: first input must be a rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[1],\n        `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `shape ${matrix.shape}.`);\n\n    return this.matMul(matrix, v.as2D(v.size, 1)).as1D();\n  }\n\n  /**\n   * Computes the dot product of two vectors, v1 * v2.\n   * @param v1 The first vector in the dot product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  dotProduct(v1: Array1D, v2: Array1D): Scalar {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in dotProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n    util.assert(\n        v1.size === v2.size,\n        `Error in dotProduct: size of inputs (${v1.size}) and (` +\n            `${v2.size}) must match.`);\n    return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar();\n  }\n\n  /**\n   * Computes the outer product of two vectors, v1 and v2.\n   * @param v1 The first vector in the outer product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  outerProduct(v1: Array1D, v2: Array1D): Array2D {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in outerProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n\n    return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size));\n  }\n\n  ///////////////\n  // Shape ops //\n  ///////////////\n\n  /**\n   * Clones an NDArray of any shape.\n   * @param ndarray The NDArray to clone.\n   */\n  clone<T extends NDArray>(ndarray: T): T {\n    return this.track(this.cloneInternal(ndarray));\n  }\n  protected abstract cloneInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Reshapes an NDArray to a new shape. The size of the input NDArray must\n   * match the size of the requested shape.\n   * @param ndarray The input NDArray.\n   * @param newShape The new shape to reshape the NDArray to. Must be the same\n   * size as the NDArray.\n   */\n  reshape<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    util.assert(\n        ndarray.size === util.sizeFromShape(newShape),\n        `Error in reshape: old size ${ndarray.size} must match new size ` +\n            `${util.sizeFromShape(newShape)}.`);\n    return this.track(this.reshapeInternal<T1, T2>(ndarray, newShape));\n  }\n  protected abstract reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2;\n\n  /**\n   * Extracts a slice from a matrix. The operation extraces a slice from input\n   * that starts at coordinates `begin` and is of size `size`.\n   * @param input The input matrix to slice from.\n   * @param begin The 2D coordinates in the input matrix to start the slice\n   * from.\n   * @param size The sice of the 2D window to slice.\n   */\n  slice2D(input: Array2D, begin: [number, number], size: [number, number]):\n      Array2D {\n    util.assert(\n        begin[0] + size[0] <= input.shape[0] &&\n            begin[1] + size[1] <= input.shape[1],\n        `Error in slice2D: requested start position ${begin} and size ` +\n            `${size} would overflow input of shape ${input.shape}.`);\n    return this.track(this.slice2DInternal(input, begin, size));\n  }\n  protected abstract slice2DInternal(\n      input: Array2D, begin: [number, number], size: [number, number]): Array2D;\n\n  /**\n   * Copies a window from the `source` matrix starting at `sourceBegin` and is\n   * of size `sourceSize` to a window in the `dest` matrix starting at\n   * `destBegin` and is of size `destSize`/\n   * @param source The source matrix to copy from.\n   * @param sourceBegin The coordinates to start the copy from.\n   * @param sourceSize The size of the copy window.\n   * @param dest The destination matrix to copy to.\n   * @param destBegin The coordinates in `dest` to copy to.\n   * @param destSize The size of the destination window.\n   */\n  copy2D(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]) {\n    util.assert(\n        sourceBegin[0] + sourceSize[0] <= source.shape[0] &&\n            sourceBegin[1] + sourceSize[1] <= source.shape[1],\n        `Error in copy2D: requested source start position ${sourceBegin} ` +\n            `and source size ${sourceSize} would overflow source NDArray` +\n            `of shape ${source.shape}.`);\n    util.assert(\n        destBegin[0] + destSize[0] <= dest.shape[0] &&\n            destBegin[1] + destSize[1] <= dest.shape[1],\n        `Error in copy2D: requested dest start position ${destBegin} ` +\n            `and source size ${destSize} would overflow dest NDArray of` +\n            `shape ${dest.shape}.`);\n    copy2d_util.validateShapes(sourceSize, destSize);\n\n    return this.copy2DInternal(\n        source, sourceBegin, sourceSize, dest, destBegin, destSize);\n  }\n  protected abstract copy2DInternal(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]): void;\n\n  /**\n   * Concatenates two 3D ndarrays along a given axis.\n   *\n   * For example, if:\n   * A: shape(2, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *\n   * B: shape(2, 1, 3) = | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * C = concat3D(A, B, axis)\n   *\n   * if axis = 0:\n   * C: shape(4, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *                     | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * if axis = 1:\n   * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |\n   *                     | r2, g2, b2, r4, g4, b4 |\n   *\n   * if axis = 2:\n   * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |\n   *                      | r2, g2, b2, r4, g4, b4 |\n   *\n   * @param ndarray1 The first array to concat.\n   * @param ndarray2 The second array to conat.\n   * @param axis The axis to concate along.\n   */\n  concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D {\n    concat3d_util.assertConcat3DShapesMatch(\n        ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: ');\n    return this.track(this.concat3DInternal(ndarray1, ndarray2, axis));\n  }\n  protected abstract concat3DInternal(\n      ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D;\n\n  ///////////////////\n  // Reduction ops //\n  ///////////////////\n\n  /**\n   * Computes the the log(sum(e ^ x)) for each x in the input ndarray.\n   * @param ndarray The input NDArray to compute the logSumExp over.\n   */\n  logSumExp(ndarray: NDArray): Scalar {\n    return this.track(this.logSumExpInternal(ndarray));\n  }\n  protected abstract logSumExpInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the sum of all the entries in the input NDArray.\n   * @param ndarray The input NDArray to compute the sum over.\n   */\n  sum(ndarray: NDArray): Scalar {\n    return this.track(this.sumInternal(ndarray));\n  }\n  protected abstract sumInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the minimum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMin(ndarray: NDArray): Scalar {\n    return this.track(this.argMinInternal(ndarray));\n  }\n  protected abstract argMinInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the maximum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMax(ndarray: NDArray): Scalar {\n    return this.track(this.argMaxInternal(ndarray));\n  }\n  protected abstract argMaxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0.\n   * @param x1 The first input NDArray.\n   * @param x2 The second input NDArray.\n   */\n  argMaxEquals(x1: NDArray, x2: NDArray): Scalar {\n    util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: ');\n    return this.track(this.argMaxEqualsInternal(x1, x2));\n  }\n  protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar;\n\n  /**\n   * Computes the top K values and flattened indices.\n   * @param ndarray The input NDArray.\n   * @param k How many top values to compute.\n   */\n  topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} {\n    util.assert(\n        k <= ndarray.size,\n        `Error in topK: k value (${k}) must be less than size of input ` +\n            `ndarray, got shape ${ndarray.shape}.`);\n    const result = this.topKInternal(ndarray, k);\n    this.track(result.values);\n    this.track(result.indices);\n    return result;\n  }\n  protected abstract topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D};\n\n  /**\n   * Computes the minimum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  min(ndarray: NDArray): Scalar {\n    return this.track(this.minInternal(ndarray));\n  }\n  protected abstract minInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the maximum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  max(ndarray: NDArray): Scalar {\n    return this.track(this.maxInternal(ndarray));\n  }\n  protected abstract maxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the softmax normalized vector from the input vector.\n   * @param x The input vector.\n   */\n  softmax(x: Array1D): Array1D {\n    return this.scope(() => {\n      // Do it in log space for numerical stability.\n      // exp(X - logSumExp(X))\n      const lse = this.logSumExp(x);\n      const logResult = this.arrayMinusScalar(x, lse);\n      return this.exp(logResult);\n    });\n  }\n\n  //////////////////////\n  // Element-wise ops //\n  //////////////////////\n\n  /**\n   * Switches dimensions of the input NDArray.\n   * @param a The input NDArray.\n   * @param newDim The new indices that define which shapes values to switch.\n   */\n  switchDim<T extends NDArray>(a: T, newDim: number[]): T {\n    util.assert(\n        a.rank === newDim.length,\n        `Error in switchDim: length of input shape ${a.shape} ` +\n            `must match size of newDim array ${newDim}.`);\n    return this.track(this.switchDimInternal(a, newDim));\n  }\n  protected abstract switchDimInternal<T extends NDArray>(\n      a: T, newDim: number[]): T;\n\n  /**\n   * Computes a scalar plus NDArray, c + A.\n   * @param c The scalar c in c + A.\n   * @param a The NDArray A in c + A.\n   */\n  scalarPlusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarPlusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarPlusArrayInternal(c, a));\n  }\n  protected abstract scalarPlusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, c - A.\n   * @param c The scalar c in c - A.\n   * @param a The NDArray A in c - A.\n   */\n  scalarMinusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarMinusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarMinusArrayInternal(c, a));\n  }\n  protected abstract scalarMinusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, A - c.\n   * @param a The NDArray A in A - c.\n   * @param c The scalar c in A - c.\n   */\n  arrayMinusScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayMinusScalar: second argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.arrayMinusScalarInternal(a, c));\n  }\n  protected abstract arrayMinusScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes -1 * A element-wise.\n   * @param a The input array.\n   */\n  neg<T extends NDArray>(a: T): T {\n    return this.track(this.negInternal(a));\n  }\n  protected abstract negInternal<T extends NDArray>(a: T): T;\n\n  /**\n   * Adds two NDArrays element-wise, A + B. Inputs must be the same shape.\n   * @param a The first NDArray to add element-wise.\n   * @param b The second NDArray to add element-wise.\n   */\n  add<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in add: ');\n    return this.track(this.addInternal(a, b));\n  }\n  protected abstract addInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape.\n   * @param a The first NDArray to subtract element-wise.\n   * @param b The second NDArray to subtract element-wise.\n   */\n  sub<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in sub: ');\n    return this.track(this.subInternal(a, b));\n  }\n  protected abstract subInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must\n   * be the same shape.\n   * @param a The first NDArray to multiply element-wise.\n   * @param b The second NDArray to multiply element-wise.\n   */\n  elementWiseMul<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: ');\n    return this.track(this.elementWiseMulInternal(a, b));\n  }\n  protected abstract elementWiseMulInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be\n   * the same shape.\n   * @param a The first NDArray to divide element-wise.\n   * @param b The second NDArray to divide element-wise.\n   */\n  divide<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in divide: ');\n    return this.track(this.divideInternal(a, b));\n  }\n  protected abstract divideInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c /\n   * A.\n   * @param c The scalar value in c / A.\n   * @param a The NDArray value in c / A.\n   */\n  scalarDividedByArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarDividedByArray: first argument must be rank 0, but ` +\n            `got NDArray of rank ${c.rank}.`);\n    return this.track(this.scalarDividedByArrayInternal(c, a));\n  }\n  protected abstract scalarDividedByArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A /\n   * c.\n   * @param a The NDArray value in A / c.\n   * @param c The scalar value in A / c.\n   */\n  arrayDividedByScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: second argument must be rank 0, ` +\n            `but got NDArray of rank ${c.rank}.`);\n    return this.track(this.arrayDividedByScalarInternal(a, c));\n  }\n  protected abstract arrayDividedByScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes exponential of the input NDArray element-wise. y = e ^ x\n   * @param ndarray The input NDArray.\n   */\n  exp<T extends NDArray>(ndarray: T): T {\n    return this.track(this.expInternal(ndarray));\n  }\n  protected abstract expInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes natural logarithm of the input NDArray element-wise. y = ln(x)\n   * @param ndarray The input NDArray.\n   */\n  log<T extends NDArray>(ndarray: T): T {\n    return this.track(this.logInternal(ndarray));\n  }\n  protected abstract logInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes rectified linear element-wise, max(x, 0).\n   * @param ndarray The input NDArray.\n   */\n  relu<T extends NDArray>(ndarray: T): T {\n    return this.track(this.reluInternal(ndarray));\n  }\n  protected abstract reluInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)).\n   * @param ndarray The input NDArray.\n   */\n  sigmoid<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sigmoidInternal(ndarray));\n  }\n  protected abstract sigmoidInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes hyperbolic tangent of the input NDArray element-wise.\n   * @param ndarray The input NDArray.\n   */\n  tanh<T extends NDArray>(ndarray: T): T {\n    return this.track(this.tanhInternal(ndarray));\n  }\n  protected abstract tanhInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sin of the input NDArray element-wise, y = sin(x).\n   * @param ndarray The input NDArray.\n   */\n  sin<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sinInternal(ndarray));\n  }\n  protected abstract sinInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <=\n   * 0\n   * @param ndarray The input NDArray.\n   */\n  step<T extends NDArray>(ndarray: T): T {\n    return this.track(this.stepInternal(ndarray));\n  }\n  protected abstract stepInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes a scaled array add operation, c1 * A + c2 * B.\n   * @param c1 The first scalar in the scaled array add computation.\n   * @param a The first NDArray in the scaled array add computation.\n   * @param c2 The second scalar in the scaled array add computation.\n   * @param cb The second NDArray in the scaled array add computation.\n   */\n  scaledArrayAdd<T extends NDArray>(c1: Scalar, a: T, c2: Scalar, b: T): T {\n    util.assert(\n        c1.size === 1,\n        `Error in scaledArrayAdd: first argument must rank 0, but got ` +\n            ` rank ${c1.rank}.`);\n    util.assert(\n        c2.size === 1,\n        `Error in scaledArrayAdd: third argument must be rank 0, but got ` +\n            `NDArray of rank ${c2.rank}.`);\n    util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: ');\n\n    return this.track(this.scaledArrayAddInternal(c1, a, c2, b));\n  }\n  protected abstract scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T): T;\n\n  /**\n   * Computes a scalar times array operation broadcasted over the NDArray, c *\n   * A.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  scalarTimesArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: first argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.scalarTimesArrayInternal(c, a));\n  }\n  protected abstract scalarTimesArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an element-wise broadcasted multiplication of two matrices A and\n   * B. Will return a new matrix that is the max of A and B, where the smaller\n   * matrix will broadcast over the larger matrix.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D {\n    util.assert(\n        a.rank === 2,\n        `Error in elementWiseMulBroadcast: first argument must be ` +\n            `rank 2, but got rank ${a.rank}.`);\n    util.assert(\n        b.rank === 2,\n        `Error in elementWiseMulBroadcast: second argument must be ` +\n            `rank 2, but got rank ${b.rank}.`);\n    return this.track(this.elementWiseMulBroadcastInternal(a, b));\n  }\n  protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D):\n      Array2D;\n\n  /////////////////////\n  // Convolution ops //\n  /////////////////////\n\n  /**\n   * Computes a 2D convolution over the input x.\n   * @param x The input image, must be rank 3, of shape [rows, cols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param zeroPad The zero padding of each side of the input NDArray. Will pad\n   * equally on all sides.\n   */\n  conv2d(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2d: weights must be rank 4, but got rank ` +\n            `${weights.rank}.`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2d: biases must be rank 1, but got rank ` +\n              `${biases.rank}.`);\n    }\n\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2d: depth of input (${x.shape[2]}) must match  ` +\n            `input depth for weights ${weights.shape[2]}.`);\n\n\n    return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad));\n  }\n  protected abstract conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D;\n\n  /**\n   * Computes the backprop of a 2D convolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param stride The stride of the original convolution.\n   * @param pad The padding of the original convolution.\n   */\n  conv2dBackProp(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dBackProp: x must be rank 3, but got shape ` +\n            `${x.shape}.`);\n    util.assert(\n        dy.rank === 3,\n        `Error in conv2dBackProp: dy must be rank 3, but got shape ` +\n            `${dy.shape}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dBackProp: weights must be rank 4, but got shape ` +\n            `${weights.shape}.`);\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` +\n            `match input depth for weights (${weights.shape[2]}.`);\n    util.assert(\n        dy.shape[2] === weights.shape[3],\n        `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` +\n            `match output depth for weights (${weights.shape[3]}).`);\n\n    const backpropResult =\n        this.conv2dBackPropInternal(x, dy, weights, stride, pad);\n\n    this.track(backpropResult.db);\n    this.track(backpropResult.dw);\n    this.track(backpropResult.dx);\n\n    return backpropResult;\n  }\n  protected abstract conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D};\n\n  /**\n   * Computes the transposed 2D convolution of an image, also known as a\n   * deconvolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  conv2dTranspose(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dTranspose: x must be rank 3, but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dTranspose: weights must be rank 4, but got ` +\n            `rank ${weights.rank}`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2dTranspose: biases must be rank 1, but got ' +\n              'rank ${biases.rank}.`);\n    }\n    util.assert(\n        x.shape[2] === weights.shape[3],\n        `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` +\n            `match input depth for weights ${weights.shape[3]}.`);\n\n    return this.track(\n        this.conv2dTransposeInternal(x, weights, biases, stride, pad));\n  }\n  protected abstract conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D max pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.');\n    return this.track(this.maxPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the backprop of a max pool.\n   * @param dy The dy error.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPoolBackprop(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        dy.rank === 3,\n        `Error in maxPoolBackprop: dy must be rank 3 but got rank ` +\n            `${dy.rank}.`);\n    util.assert(\n        x.rank === 3,\n        `Error in maxPoolBackprop: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n\n    return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad));\n  }\n  protected abstract maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D min pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in minPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.minPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the 2D average pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.avgPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /*\n   * Bilinear resize a 3D array per each channel to a new 2D shape.\n   * @param x The input Array3D.\n   * @param newShape2D The new shape to resize the Array3D to. Each channel is\n   * resized individually.\n   * @param alignCorners An optional bool. Defaults to False. If true, rescale\n   * input by (new_height - 1) / (height - 1), which exactly aligns the 4\n   * corners of images and resized images. If false, rescale by new_height /\n   * height. Treat similarly the width dimension.\n   */\n  resizeBilinear3D(\n      x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`);\n    util.assert(\n        newShape2D.length === 2,\n        `Error in resizeBilinear3D: new shape must 2D, but got shape ` +\n            `${newShape2D}.`);\n    return this.track(\n        this.resizeBilinear3DInternal(x, newShape2D, alignCorners));\n  }\n  protected abstract resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D;\n\n  /**\n   * Batch normalization 3D. Mean, variance, scale, and offset can be of two\n   * shapes: 1) The same shape as the input: an Array3D. 2) In the common case,\n   * the depth dimension is the last dimension of x, so the values would be an\n   * Array1D of shape [depth].\n   * @param x The input NDArray.\n   * @param mean A mean NDArray.\n   * @param variance A variance NDArray.\n   * @param varianceEpsilon A small float number to avoid dividing by 0.\n   * @param scale A scale NDArray.\n   * @param offset An offset NDArray.\n   */\n  batchNormalization3D(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in batchNormalization3D: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        mean.rank === 3 || mean.rank === 1,\n        `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` +\n            `got rank ${mean.rank}.`);\n    util.assert(\n        variance.rank === 3 || variance.rank === 1,\n        `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` +\n            `but got rank ${variance.rank}.`);\n    if (scale != null) {\n      util.assert(\n          scale.rank === 3 || scale.rank === 1,\n          `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` +\n              `but got rank ${scale!.rank}.`);\n    }\n    if (offset != null) {\n      util.assert(\n          offset.rank === 3 || offset.rank === 1,\n          `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` +\n              `but got rank ${offset!.rank}.`);\n    }\n\n    return this.track(this.batchNormalization3DInternal(\n        x, mean, variance, varianceEpsilon, scale, offset));\n  }\n  protected abstract batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D;\n}\n\nexport enum MatrixOrientation {\n  REGULAR,\n  TRANSPOSED\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../math/conv_util';\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2D_util from './copy2d_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport class NDArrayMathCPU extends NDArrayMath {\n  constructor(safeMode = false) {\n    super(safeMode);\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    return NDArray.make<T>(\n        ndarray.shape, {values: new Float32Array(ndarray.getValues())});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    return this.cloneInternal(ndarray).reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = Array2D.zeros(sizeRowCol);\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol);\n    const srcValues = source.getValues();\n    const dstValues = dest.getValues();\n    const n = sourceSizeRowCol[0] * sourceSizeRowCol[1];\n    for (let i = 0; i < n; ++i) {\n      const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]);\n      const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]);\n      const srcOff = srcRow * source.shape[1] + srcCol;\n      const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]);\n      const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]);\n      const dstOff = dstRow * dest.shape[1] + dstCol;\n      dstValues[dstOff] = srcValues[srcOff];\n    }\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const outputShape =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const values = NDArray.zeros<Array3D>(outputShape);\n\n    for (let i = 0; i < outputShape[0]; i++) {\n      for (let j = 0; j < outputShape[1]; j++) {\n        for (let k = 0; k < outputShape[2]; k++) {\n          // Shader begins.\n          const index: [number, number, number] = [i, j, k];\n          let value: number;\n          if (index[axis] < x1.shape[axis]) {\n            value = x1.get(i, j, k);\n          } else {\n            index[axis] -= x1.shape[axis];\n            const [i2, j2, k2] = index;\n            value = x2.get(i2, j2, k2);\n          }\n\n          values.set(value, i, j, k);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const resultValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < resultValues.length; ++i) {\n      resultValues[i] = cVal + aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: resultValues});\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    const cValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    const c1Val = c1.get();\n    const c2Val = c2.get();\n    for (let i = 0; i < cValues.length; ++i) {\n      cValues[i] = c1Val * aValues[i] + c2Val * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: cValues});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cVal * aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const negA = this.negInternal(a);\n    const result = this.scalarPlusArrayInternal(c, negA);\n\n    negA.dispose();\n\n    return result;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    const negC = this.negInternal(c);\n    const result = this.scalarPlusArrayInternal(negC, a);\n\n    negC.dispose();\n\n    return result;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a);\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.ONE, b);\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.NEG_ONE, b);\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n\n    const leftDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const rightDim =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n\n    const normalGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(i, j);\n    const transposedGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(j, i);\n\n    const aGetter = (aOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const bGetter = (bOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const values = new Float32Array(leftDim * rightDim);\n    let index = 0;\n\n    for (let i = 0; i < leftDim; ++i) {\n      for (let j = 0; j < rightDim; ++j) {\n        let sum = 0;\n        for (let k = 0; k < sharedDim; ++k) {\n          // TODO: optimize CPU matmul.\n          sum += aGetter(a, i, k) * bGetter(b, k, j);\n        }\n        values[index++] = sum;\n      }\n    }\n    return Array2D.new([leftDim, rightDim], values);\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    const maxRow = Math.max(a.shape[0], b.shape[0]);\n    const maxCol = Math.max(a.shape[1], b.shape[1]);\n\n    const values = new Float32Array(maxRow * maxCol);\n    let index = 0;\n    for (let row = 0; row < maxRow; row++) {\n      for (let col = 0; col < maxCol; col++) {\n        values[index++] = a.get(row % a.shape[0], col % a.shape[1]) *\n            b.get(row % b.shape[0], col % b.shape[1]);\n      }\n    }\n    return Array2D.new([maxRow, maxCol], values);\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cValue / aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / cValue;\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    let sum = 0;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      sum += values[i];\n    }\n    return Scalar.new(sum);\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    let min = Number.MAX_VALUE;\n    let minIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n        minIndex = i;\n      }\n    }\n    return Scalar.new(minIndex);\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    let max = Number.NEGATIVE_INFINITY;\n    let maxIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n    return Scalar.new(maxIndex);\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    const argMax1 = this.argMaxInternal(x1).get();\n    const argMax2 = this.argMaxInternal(x2).get();\n    if (isNaN(argMax1) || isNaN(argMax2)) {\n      return Scalar.new(NaN);\n    }\n    return Scalar.new(+(argMax1 === argMax2));\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    const values = ndarray.getValues();\n    const valuesAndIndices: Array<{value: number, index: number}> = [];\n    for (let i = 0; i < values.length; i++) {\n      valuesAndIndices.push({value: values[i], index: i});\n    }\n    valuesAndIndices.sort((a, b) => {\n      return b.value - a.value;\n    });\n    const topkValues = new Float32Array(k);\n    const topkIndices = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n      topkValues[i] = valuesAndIndices[i].value;\n      topkIndices[i] = valuesAndIndices[i].index;\n    }\n    return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)};\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let min = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n      }\n    }\n    return Scalar.new(min);\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let max = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n      }\n    }\n    return Scalar.new(max);\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      newValues[i] = Math.exp(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      newValues[i] = Math.log(value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const xMax = this.max(ndarray);\n    const a = this.arrayMinusScalar(ndarray, xMax);\n    const b = this.exp(a);\n    const c = this.sum(b);\n    const d = this.log(c);\n    const result = this.add(xMax, d);\n\n    xMax.dispose();\n    a.dispose();\n    b.dispose();\n    c.dispose();\n    d.dispose();\n\n    return result;\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.max(0, values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = 1 / (1 + Math.exp(-values[i]));\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = util.tanh(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.sin(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    const [xRows, xCols, inputDepth] = x.shape;\n    const fieldSize = weights.shape[0];\n    const outputDepth = weights.shape[3];\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fieldSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fieldSize + xCCorner);\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              for (let d1 = 0; d1 < inputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight = weights.get(wR, wC, d1, d2);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = (biases != null) ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad);\n    return {dx, db, dw};\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const fSize = weights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR - pad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / origStride));\n        const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride);\n\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC - pad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / origStride));\n          const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride);\n\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR * origStride - xRCorner;\n\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC * origStride - xCCorner;\n\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = biases != null ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeShaderLike(\n      x: Array3D, origWeights: Array4D, origStride: number,\n      origPad: number): Array3D {\n    const fSize = origWeights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = origWeights.shape[2];\n    const origOutputDepth = origWeights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          // Shader code begins.\n          const xRCorner = yR - pad;\n          const xCCorner = yC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const xR = (xRCorner + wR) / origStride;\n            if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const xC = (xCCorner + wC) / origStride;\n              if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) {\n                continue;\n              }\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          y.set(dotProd, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    const dW = Array4D.zeros(weightsShape);\n\n    const yNumRows = dY.shape[0];\n    const yNumCols = dY.shape[1];\n    const xNumRows = x.shape[0];\n    const xNumCols = x.shape[1];\n\n    for (let wR = 0; wR < fSize; ++wR) {\n      const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride));\n      const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride);\n\n      for (let wC = 0; wC < fSize; ++wC) {\n        const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride));\n        const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride);\n\n        for (let d1 = 0; d1 < inputDepth; ++d1) {\n          for (let d2 = 0; d2 < outputDepth; ++d2) {\n            // Need to convolve.\n            let dotProd = 0;\n            for (let yR = yRMin; yR < yRMax; ++yR) {\n              const xR = wR + yR * stride - zeroPad;\n              for (let yC = yCMin; yC < yCMax; ++yC) {\n                const xC = wC + yC * stride - zeroPad;\n                dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2);\n              }\n            }\n            dW.set(dotProd, wR, wC, d1, d2);\n          }\n        }\n      }\n    }\n    return dW;\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const numRows = dY.shape[0];\n    const numCols = dY.shape[1];\n    const values = new Float32Array(outputDepth);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      let sum = 0;\n      for (let r = 0; r < numRows; ++r) {\n        for (let c = 0; c < numCols; ++c) {\n          sum += dY.get(r, c, d2);\n        }\n      }\n      values[d2] = sum;\n    }\n    return Array1D.new(values);\n  }\n\n  protected switchDimInternal<T extends NDArray>(t: T, newDim: number[]): T {\n    const newShape: number[] = new Array(t.rank);\n    for (let i = 0; i < newShape.length; i++) {\n      newShape[i] = t.shape[newDim[i]];\n    }\n    const resultValues = new Float32Array(t.size);\n    const values = t.getValues();\n    const result = NDArray.make<T>(newShape, {values: resultValues});\n    for (let i = 0; i < t.size; ++i) {\n      const loc = t.indexToLoc(i);\n\n      // Permute location.\n      const newLoc: number[] = new Array(loc.length);\n      for (let i = 0; i < newLoc.length; i++) {\n        newLoc[i] = loc[newDim[i]];\n      }\n\n      const newIndex = result.locToIndex(newLoc);\n      resultValues[newIndex] = values[i];\n    }\n    return result;\n  }\n\n  private pool(\n      x: Array3D, fSize: number, stride: number, pad: number,\n      poolType: 'max'|'min'|'avg') {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, depth], fSize, depth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n\n\n          let minMaxValue =\n              (poolType === 'max' ? Number.NEGATIVE_INFINITY :\n                                    Number.POSITIVE_INFINITY);\n          let avgValue = 0;\n\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (isNaN(pixel)) {\n                minMaxValue = NaN;\n                avgValue = NaN;\n                break;\n              }\n              if ((poolType === 'max' && pixel > minMaxValue) ||\n                  (poolType === 'min' && pixel < minMaxValue)) {\n                minMaxValue = pixel;\n              } else if (poolType === 'avg') {\n                avgValue += pixel / (fSize * fSize);\n              }\n            }\n            if (isNaN(minMaxValue)) {\n              break;\n            }\n          }\n          y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'max');\n  }\n\n  maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad);\n    const maxPositions = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < outputShape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < outputShape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n          let maxValue = Number.NEGATIVE_INFINITY;\n          let maxPosition = -1;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (pixel > maxValue) {\n                maxValue = pixel;\n                maxPosition = wR * fSize + wC;\n              }\n            }\n          }\n          maxPositions.set(maxPosition, yR, yC, d);\n        }\n      }\n    }\n    return maxPositions;\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad);\n    const pad = fSize - 1 - origPad;\n    const [dyRows, dyCols, depth] = dy.shape;\n\n    // Dilate the input.\n    const dyRowsDilated = (dyRows - 1) * origStride + 1;\n    const dxColsDilated = (dyCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad);\n    const dx = Array3D.zeros(outputShape);\n\n    for (let d = 0; d < depth; ++d) {\n      for (let dxR = 0; dxR < dx.shape[0]; ++dxR) {\n        for (let dxC = 0; dxC < dx.shape[1]; ++dxC) {\n          // Shader code begins.\n          const dyRCorner = dxR - pad;\n          const dyCCorner = dxC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const dyR = (dyRCorner + wR) / origStride;\n            if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const dyC = (dyCCorner + wC) / origStride;\n              if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) {\n                continue;\n              }\n              const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d);\n              const curPos = wR * fSize + wC;\n\n              const mask = maxPos === curPos ? 1 : 0;\n              if (mask === 0) {\n                continue;\n              }\n\n              const pixel = dy.get(dyR, dyC, d);\n              dotProd += pixel * mask;\n            }\n          }\n          dx.set(dotProd, dxR, dxC, d);\n        }\n      }\n    }\n    return dx;\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'min');\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'avg');\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]);\n\n    const effectiveInputSize =\n        alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape;\n    const effectiveOutputSize = alignCorners ?\n        [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] :\n        output.shape;\n    for (let r = 0; r < output.shape[0]; r++) {\n      for (let c = 0; c < output.shape[1]; c++) {\n        for (let d = 0; d < output.shape[2]; d++) {\n          // Begin shader.\n\n          // Compute the fractional index of the source.\n          const sourceFracRow =\n              (effectiveInputSize[0]) * r / (effectiveOutputSize[0]);\n          const sourceFracCol =\n              (effectiveInputSize[1]) * c / (effectiveOutputSize[1]);\n\n          const sourceRowFloor = Math.floor(sourceFracRow);\n          const sourceRowCeil =\n              Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow));\n          const sourceColFloor = Math.floor(sourceFracCol);\n          const sourceColCeil =\n              Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol));\n\n          const topLeft = x.get(sourceRowFloor, sourceColFloor, d);\n          const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d);\n          const topRight = x.get(sourceRowFloor, sourceColCeil, d);\n          const bottomRight = x.get(sourceRowCeil, sourceColCeil, d);\n\n          const rowFrac = sourceFracRow - sourceRowFloor;\n          const colFrac = sourceFracCol - sourceColFloor;\n\n          const top = topLeft + (topRight - topLeft) * colFrac;\n          const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;\n          const newValue = top + (bottom - top) * rowFrac;\n\n          output.set(newValue, r, c, d);\n        }\n      }\n    }\n\n    return output;\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xValues = x.getValues();\n    const meanValues = mean.getValues();\n    const varianceValues = variance.getValues();\n    const scaleValues = scale ? scale.getValues() : new Float32Array([1]);\n    const offsetValues = offset ? offset.getValues() : new Float32Array([0]);\n    const outValues = new Float32Array(xValues.length);\n\n    for (let i = 0; i < xValues.length; i++) {\n      outValues[i] = offsetValues[i % offsetValues.length] +\n          (xValues[i] - meanValues[i % meanValues.length]) *\n              scaleValues[i % scaleValues.length] /\n              Math.sqrt(\n                  varianceValues[i % varianceValues.length] + varianceEpsilon);\n    }\n    return NDArray.make<Array3D>(x.shape, {values: outValues});\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as webgl_util from './webgl/webgl_util';\n\n// These global variables need to be initialized to null so that closure knows\n// not to seal them.\n/** @hidden */\nexport let GPGPU: GPGPUContext = null!;\n/** @hidden */\nexport let TEXTURE_MANAGER: TextureManager = null!;\n\n/** @hidden */\nexport interface NDArrayData {\n  values?: Float32Array;\n  texture?: WebGLTexture;\n  /** [rows, columns] shape of the texture. */\n  textureShapeRC?: [number, number];\n}\n\n/** @hidden */\nexport function initializeGPU(\n    gpgpu: GPGPUContext, textureManager: TextureManager) {\n  GPGPU = gpgpu;\n  TEXTURE_MANAGER = textureManager;\n}\n\nfunction throwIfGPUNotInitialized() {\n  if (GPGPU == null || TEXTURE_MANAGER == null) {\n    throw new Error('GPU not intialized.');\n  }\n}\n\nexport class NDArray {\n  /** The shape of the ndarray. */\n  shape: number[];\n  /** Number of elements in the ndarray. */\n  size: number;\n\n  /**\n   * Number of elements to skip in each dimension when indexing. See\n   * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html\n   */\n  protected strides: number[];\n\n  private data: NDArrayData;\n\n  protected constructor(shape: number[], data: NDArrayData) {\n    // Sanity checks.\n    util.assert(\n        data.values != null || data.texture != null,\n        'Either `values` or `texture` must be defined');\n\n    util.assert(\n        data.texture == null || (data.textureShapeRC != null),\n        '`textureShape` must be defined when `texture` is defined');\n\n    this.size = util.sizeFromShape(shape);\n\n    if (data.values != null) {\n      util.assert(\n          this.size === data.values.length,\n          'Constructing ndarray of shape (' + this.size + ') should match the' +\n              ' length of values (' + data.values.length + ')');\n    }\n\n    this.shape = shape;\n    this.data = data;\n    const dim = this.shape.length;\n\n    if (dim < 2) {\n      this.strides = [];\n    } else {\n      // Last dimension has implicit stride of 1, thus having D-1 (instead of D)\n      // strides.\n      this.strides = new Array(dim - 1);\n      this.strides[dim - 2] = this.shape[dim - 1];\n      for (let i = dim - 3; i >= 0; --i) {\n        this.strides[i] = this.strides[i + 1] * this.shape[i + 1];\n      }\n    }\n  }\n\n  /** Creates a ndarray of zeros with the specified shape. */\n  static zeros<T extends NDArray>(shape: number[]): T {\n    const values = new Float32Array(util.sizeFromShape(shape));\n    return NDArray.make<T>(shape, {values});\n  }\n\n  /** Creates a ndarray of zeros with the same shape as the specified ndarray.\n   */\n  static zerosLike<T extends NDArray>(another: T): T {\n    return NDArray.zeros(another.shape) as T;\n  }\n\n  /** Creates a ndarray with the same values/shape as the specified ndarray. */\n  static like<T extends NDArray>(another: T): T {\n    const values = another.getValues();\n    return NDArray.make<T>(another.shape, {values: new Float32Array(values)});\n  }\n\n  /**\n   * Makes a new ndarray with the provided shape and values. Values should be in\n   * a flat array.\n   */\n  static make<T extends NDArray>(shape: number[], data: NDArrayData): T {\n    switch (shape.length) {\n      case 0:\n        return new Scalar(data) as T;\n      case 1:\n        // tslint:disable-next-line:no-any\n        return new Array1D(data) as any;\n      case 2:\n        // tslint:disable-next-line:no-any\n        return new Array2D(shape as [number, number], data) as any;\n      case 3:\n        // tslint:disable-next-line:no-any\n        return new Array3D(shape as [number, number, number], data) as any;\n      case 4:\n        return new Array4D(\n                   // tslint:disable-next-line:no-any\n                   shape as [number, number, number, number], data) as any;\n      default:\n        // tslint:disable-next-line:no-any\n        return new NDArray(shape, data) as any;\n    }\n  }\n\n  /** Reshapes the current ndarray into the provided shape. */\n  reshape<T extends NDArray>(newShape: number[]): T {\n    if (util.arraysEqual(this.shape, newShape)) {\n      // No-op.\n      // tslint:disable-next-line:no-any\n      return this as any;\n    }\n\n    util.assert(\n        this.size === util.sizeFromShape(newShape),\n        'new shape and old shape must have the same number of elements.');\n\n    return NDArray.make<T>(newShape, this.data);\n  }\n\n  asScalar(): Scalar {\n    util.assert(this.size === 1, 'The array must have only 1 element.');\n    return this.reshape<Scalar>([]);\n  }\n\n  as1D(): Array1D {\n    return this.reshape<Array1D>([this.size]);\n  }\n\n  as2D(rows: number, columns: number): Array2D {\n    return this.reshape<Array2D>([rows, columns]);\n  }\n\n  as3D(rows: number, columns: number, depth: number): Array3D {\n    return this.reshape<Array3D>([rows, columns, depth]);\n  }\n\n  as4D(rows: number, columns: number, depth: number, depth2: number): Array4D {\n    return this.reshape<Array4D>([rows, columns, depth, depth2]);\n  }\n\n  get rank(): number {\n    return this.shape.length;\n  }\n\n  get(...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return this.getValues()[index];\n  }\n\n  add(value: number, ...locs: number[]) {\n    this.set(this.get(...locs) + value, ...locs);\n  }\n\n  set(value: number, ...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    this.getValues()[index] = value;\n  }\n\n  locToIndex(locs: number[]): number {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return index;\n  }\n\n  indexToLoc(index: number): number[] {\n    const locs: number[] = new Array(this.shape.length);\n    for (let i = 0; i < locs.length - 1; ++i) {\n      locs[i] = Math.floor(index / this.strides[i]);\n      index -= locs[i] * this.strides[i];\n    }\n    locs[locs.length - 1] = index;\n    return locs;\n  }\n\n  fill(value: number) {\n    this.getValues().fill(value);\n  }\n\n  getData(): NDArrayData {\n    return this.data;\n  }\n\n  getValues(): Float32Array {\n    if (this.data.values == null) {\n      throwIfGPUNotInitialized();\n      this.data.values = GPGPU.downloadMatrixFromTexture(\n          this.data.texture!, this.data.textureShapeRC![0],\n          this.data.textureShapeRC![1]);\n      this.disposeTexture();\n    }\n    return this.data.values;\n  }\n\n  private uploadToGPU(preferredTexShape?: [number, number]) {\n    throwIfGPUNotInitialized();\n    this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(\n        GPGPU.gl, this.shape, preferredTexShape);\n    this.data.texture =\n        TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC);\n\n    GPGPU.uploadMatrixToTexture(\n        this.data.texture, this.data.textureShapeRC[0],\n        this.data.textureShapeRC[1], this.data.values!);\n\n    this.data.values = null!;\n  }\n\n  getTexture(preferredShapeRC?: [number, number]): WebGLTexture {\n    if (this.data.texture == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.texture!;\n  }\n\n  getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] {\n    if (this.data.textureShapeRC == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.textureShapeRC!;\n  }\n\n  dispose(): void {\n    this.data.values = null!;\n    this.shape = null!;\n    if (this.data.texture != null) {\n      this.disposeTexture();\n    }\n  }\n\n  private disposeTexture() {\n    throwIfGPUNotInitialized();\n    TEXTURE_MANAGER.releaseTexture(\n        this.data.texture!, this.data.textureShapeRC!);\n    this.data.texture = null!;\n    this.data.textureShapeRC = null!;\n  }\n\n  inGPU(): boolean {\n    return this.data.texture != null;\n  }\n\n  equals(t: NDArray): boolean {\n    return util.arraysEqual(this.shape, t.shape) &&\n        util.arraysEqual(this.getValues(), t.getValues());\n  }\n\n  static rand<T extends NDArray>(shape: number[], randFunction: () => number):\n      T {\n    const size = util.sizeFromShape(shape);\n    const values = new Float32Array(size);\n    for (let i = 0; i < size; i++) {\n      values[i] = randFunction();\n    }\n\n    return NDArray.make<T>(shape, {values});\n  }\n\n  static randNormal<T extends NDArray>(shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev));\n  }\n\n  static randTruncatedNormal<T extends NDArray>(\n      shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev, true));\n  }\n\n  static randUniform<T extends NDArray>(shape: number[], a: number, b: number) {\n    return NDArray.rand<T>(shape, () => util.randUniform(a, b));\n  }\n}\n\nexport class Scalar extends NDArray {\n  constructor(data: NDArrayData) {\n    if (data.texture != null) {\n      data.textureShapeRC = [1, 1];\n    }\n    super([], data);\n  }\n\n  static new(value: number) {\n    return new Scalar({values: new Float32Array([value])});\n  }\n\n  static ZERO = Scalar.new(0);\n  static ONE = Scalar.new(1);\n  static TWO = Scalar.new(2);\n  static NEG_ONE = Scalar.new(-1);\n\n  get(): number {\n    return this.getValues()[0];\n  }\n\n  set(value: number) {\n    this.getValues()[0] = value;\n  }\n\n  add(value: number) {\n    this.getValues()[0] += value;\n  }\n}\n\nexport class Array1D extends NDArray {\n  shape: [number];\n\n  constructor(data: NDArrayData) {\n    const shape = (data.values != null) ?\n        [data.values.length] :\n        [util.sizeFromShape(data.textureShapeRC!)];\n    super(shape, data);\n  }\n\n  static new(values: Float32Array|number[]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      util.assert(\n          inferredShape.length === 1,\n          `Error constructing Array1D. Shape of values ${inferredShape} is ` +\n              `not 1 dimensional.`);\n    }\n    return new Array1D({values: toTypedArray(values)});\n  }\n\n  get(i: number): number {\n    return this.getValues()[i];\n  }\n\n  set(value: number, i: number) {\n    this.getValues()[i] = value;\n  }\n\n  add(value: number, i: number) {\n    this.getValues()[i] += value;\n  }\n\n  locToIndex(loc: [number]): number {\n    return loc[0];\n  }\n\n  indexToLoc(index: number): [number] {\n    return [index];\n  }\n\n  static zeros(shape: [number]): Array1D {\n    return NDArray.zeros<Array1D>(shape);\n  }\n}\n\nexport class Array2D extends NDArray {\n  shape: [number, number];\n\n  private stride0: number;\n\n  constructor(shape: [number, number], data: NDArrayData) {\n    util.assert(shape.length === 2, 'Shape should be of length 2');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n  }\n\n  static new(\n      shape: [number, number], values: Float32Array|number[]|number[][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array2D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array2D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number) {\n    return this.getValues()[this.stride0 * i + j];\n  }\n\n  set(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] = value;\n  }\n\n  add(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] += value;\n  }\n\n  locToIndex(locs: [number, number]): number {\n    return this.stride0 * locs[0] + locs[1];\n  }\n\n  indexToLoc(index: number): [number, number] {\n    return [Math.floor(index / this.stride0), index % this.stride0];\n  }\n\n  static zeros(shape: [number, number]): Array2D {\n    return NDArray.zeros<Array2D>(shape);\n  }\n}\n\nexport class Array3D extends NDArray {\n  shape: [number, number, number];\n  private stride0: number;\n  private stride1: number;\n\n  constructor(shape: [number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 3, 'Shape should be of length 3');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n  }\n\n  static new(\n      shape: [number, number, number],\n      values: Float32Array|number[]|number[][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array3D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array3D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number) {\n    return this.getValues()[this.stride0 * i + this.stride1 * j + k];\n  }\n\n  set(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] += value;\n  }\n\n  locToIndex(locs: [number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2];\n  }\n\n  indexToLoc(index: number): [number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    return [i, Math.floor(index / this.stride1), index % this.stride1];\n  }\n\n  static zeros(shape: [number, number, number]): Array3D {\n    return NDArray.zeros<Array3D>(shape);\n  }\n}\n\nexport class Array4D extends NDArray {\n  shape: [number, number, number, number];\n  private stride0: number;\n  private stride1: number;\n  private stride2: number;\n\n  constructor(shape: [number, number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 4, 'Shape should be of length 4');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n    this.stride2 = this.strides[2];\n  }\n\n  static new(\n      shape: [number, number, number, number],\n      values: Float32Array|number[]|number[][][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array4D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array4D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number, l: number) {\n    return this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l];\n  }\n\n  set(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value;\n  }\n\n  locToIndex(locs: [number, number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] +\n        this.stride2 * locs[2] + locs[3];\n  }\n\n  indexToLoc(index: number): [number, number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    const j = Math.floor(index / this.stride1);\n    index -= j * this.stride1;\n    return [i, j, Math.floor(index / this.stride2), index % this.stride2];\n  }\n\n  static zeros(shape: [number, number, number, number]): Array4D {\n    return NDArray.zeros<Array4D>(shape);\n  }\n}\n\ntype ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][];\n\nfunction toTypedArray(a: ArrayData): Float32Array {\n  return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a));\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport * as conv_gpu from './conv_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderDerWeightsSource(\n    xShapeRowColDepth: [number, number, number], fSize: number,\n    outputDepth: number, stride: number, zeroPad: number) {\n  const getMatrixValueOrZeroPad =\n      conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const inputDepth = xShapeRowColDepth[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth);\n\n  const yShape = conv_util.computeOutputShape3D(\n      xShapeRowColDepth, fSize, outputDepth, stride, zeroPad);\n  const yNumRows = yShape[0];\n  const yNumCols = yShape[1];\n  const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape);\n\n  const fSizeTimesInputDepth = fSize * inputDepth;\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D dy;\n  `;\n\n  return prologue + '\\n' + getMatrixValueOrZeroPad + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]});\n\n    void main() {\n      vec2 wTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n      float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0);\n      float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0;\n      float wC = floor(wTexRLeftover / ${inputDepth}.0);\n      float d1 = mod(wTexRLeftover, ${inputDepth}.0);\n      float d2 = wTexCR.x;\n\n      // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float xR = wR + yR * ${stride}.0 - ${zeroPad}.0;\n        float xTexR = xR;\n        float yTexR = yR;\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          float xC = wC + yC * ${stride}.0 - ${zeroPad}.0;\n\n          // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) +\n                        vec2(d1, d2);\n          float xTexC = xyTexC.x;\n          float yTexC = xyTexC.y;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read x(xR, xC, d1) (potentially zero-padded).\n          float xValue =\n            getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n          dotProd += (xValue * dyValue);\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderConvTransposeSource(\n    xShapeRCD: [number, number, number], fSize: number, origInputDepth: number,\n    origStride: number, origPad: number, hasBias: boolean) {\n  const pad = fSize - 1 - origPad;\n  const [xRows, xCols, origOutputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize);\n\n  const getBiasValue = hasBias ?\n      conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) :\n      '';\n  const biasPrologue = hasBias ? 'uniform sampler2D biases;' : '';\n  const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : '';\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    ${biasPrologue}\n    `;\n\n  return prologue + '\\n' + getBiasValue + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${origInputDepth}.0);\n      float d2 = mod(yTexCR.x, ${origInputDepth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float xR = (xRCorner + wR) / ${origStride}.0;\n        // TODO(smilkov): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) {\n          continue;\n        }\n\n        float wRPerm = ${fSize}.0 - 1.0 - wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float xC = (xCCorner + wC) / ${origStride}.0;\n          if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) {\n            continue;\n          }\n\n          float wCPerm = ${fSize}.0 - 1.0 - wC;\n          float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 +\n                        wCPerm * ${origInputDepth}.0 + d2;\n\n          for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${origOutputDepth}.0 + d1;\n            float wTexC = d1;\n\n            // Read x(xR, xC, d1).\n            vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n            float xValue = texture2D(x, xUV).r;\n\n            // Read w(wRPerm, wCPerm, d2, d1).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      ${biasOperation}\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderDerBiasSource(\n    dyShapeRCD: [number, number, number]) {\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const [yNumRows, yNumCols, outputDepth] = dyShapeRCD;\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n      // The bias texture RC shape is [1, d2].\n      float d2 = biasTexCR.x;\n\n      float derBias = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float yTexR = yR;\n\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          float yTexC = yC * ${outputDepth}.0 + d2;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          derBias += dyValue;\n        }\n      }\n      gl_FragColor = vec4(derBias, 0, 0, 0);\n    }`;\n}\n\nexport function derBias(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    result: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.executeProgram();\n}\n\nexport function derWeights(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    dyTex: WebGLTexture, result: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 1);\n  gpgpu.executeProgram();\n}\n\nexport function convTranspose(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    weightsTex: WebGLTexture, biasesTex: WebGLTexture|null,\n    resultTex: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1);\n  if (biasesTex != null) {\n    gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    uniform sampler2D biases;\n    varying vec2 resultUV;`;\n}\n\nexport function getFragmentShaderGetMatrixValueOrZeroPadSource(): string {\n  return `\n    float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n        vec2 requestedCR) {\n      vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n      float value = texture2D(matrix, uv).r;\n      bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n      bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n      bool outside = lessThanZero || greaterThanOne;\n      return mix(value, 0.0, float(outside));\n    }`;\n}\n\nexport function getFragmentShaderConvolveSource(\n    xShapeRCD: [number, number, number], fSize: number, outputDepth: number,\n    stride: number, pad: number, hasBias: boolean) {\n  const [xRows, xCols, inputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n\n  return `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${outputDepth}.0);\n      float d2 = mod(yTexCR.x, ${outputDepth}.0);\n      float wTexC = d2;\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n\n          for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${inputDepth}.0 + d1;\n            float wTexR = wR * ${fSize * inputDepth}.0 +\n                wC * ${inputDepth}.0 + d1;\n\n            float xValue =\n                getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n            // Read w(wR, wC, d1, d2).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      if (${hasBias}) {\n        dotProd += getBiasValue(biases, d2);\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderGetBiasValueSource(outputDepth: number):\n    string {\n  return `\n    float getBiasValue(in sampler2D bias, float biasC) {\n      const vec2 biasShapeCR = vec2(${outputDepth}, 1);\n      vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0);\n      vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n      return texture2D(bias, biasUV).r;\n    }`;\n}\n\nexport function getFragmentShaderSource(\n    aShapeRowColDepth: [number, number, number], resultDepth: number,\n    fieldSize: number, stride: number, zeroPad: number,\n    hasBias: boolean): string {\n  const aShapeRC: [number, number] =\n      conv_util.computeTexShapeFrom3D(aShapeRowColDepth);\n\n  const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape(\n      aShapeRowColDepth[2], resultDepth, fieldSize);\n\n  const prologue = getFragmentShaderPrologueSource();\n  const getMatrixValueOrZeroPad =\n      getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const convolve = getFragmentShaderConvolveSource(\n      aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias);\n  const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth);\n\n  return [\n    prologue,\n    getMatrixValueOrZeroPad,\n    getBiasValue,\n    convolve,\n  ].join('\\n');\n}\n\nexport function convolve(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'x', 0);\n  gpgpu.setInputMatrixTexture(weights, 'weights', 1);\n  if (biases != null) {\n    gpgpu.setInputMatrixTexture(biases, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from './gpgpu_util';\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nimport {WebGLLoseContextExtension} from './webgl_util';\n\nexport class GPGPUContext {\n  gl: WebGLRenderingContext;\n  textureFloatExtension: {};\n  colorBufferFloatExtension: {};\n  loseContextExtension: WebGLLoseContextExtension;\n  vertexBuffer: WebGLBuffer;\n  indexBuffer: WebGLBuffer;\n  framebuffer: WebGLFramebuffer;\n  outputTexture: WebGLTexture|null = null;\n  program: WebGLProgram|null = null;\n  private disposed = false;\n  private autoDebugValidate = false;\n\n  constructor(gl?: WebGLRenderingContext) {\n    if (gl != null) {\n      this.gl = gl;\n    } else {\n      this.gl = gpgpu_util.createWebGLContext();\n    }\n\n    // WebGL 2.0 enables texture floats without an extension.\n    if (!webgl_util.isWebGL2Enabled()) {\n      this.textureFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float');\n    } else {\n      this.colorBufferFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float');\n    }\n\n    this.loseContextExtension =\n        webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as\n        WebGLLoseContextExtension;\n    this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl);\n    this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl);\n    this.framebuffer = webgl_util.createFramebuffer(this.gl);\n  }\n\n  public dispose() {\n    this.throwIfDisposed();\n    if (this.program != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound WebGLProgram.' +\n          ' This is probably a resource leak, delete the program with ' +\n          'GPGPUContext.deleteProgram before disposing.');\n    }\n    if (this.outputTexture != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound output matrix ' +\n          'texture.  This is probably a resource leak, delete the output ' +\n          'matrix texture with GPGPUContext.deleteMatrixTexture before ' +\n          'disposing.');\n    }\n    const gl = this.gl;\n    webgl_util.callAndCheck(gl, () => gl.finish());\n    webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer));\n    webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer));\n    webgl_util.callAndCheck(\n        gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer));\n    this.loseContextExtension.loseContext();\n    this.disposed = true;\n  }\n\n  public enableAutomaticDebugValidation(enabled: boolean) {\n    this.autoDebugValidate = enabled;\n    webgl_util.enableDebugWebGLErrorChecking(enabled);\n  }\n\n  public createMatrixTexture(rows: number, columns: number): WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createMatrixTexture(this.gl, rows, columns);\n  }\n\n  public uploadPixelDataToTexture(\n      texture: WebGLTexture,\n      pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n    this.throwIfDisposed();\n    gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels);\n  }\n\n  public createPackedMatrixTexture(rows: number, columns: number):\n      WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns);\n  }\n\n  public deleteMatrixTexture(texture: WebGLTexture) {\n    this.throwIfDisposed();\n    if (this.outputTexture === texture) {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n      this.outputTexture = null;\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture));\n  }\n\n  public uploadMatrixToTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    const numChannels = 1;\n    return gpgpu_util.uploadMatrixToTexture(\n        this.gl, texture, rows, columns, matrix, numChannels);\n  }\n\n  public uploadMatrixToPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    return gpgpu_util.uploadMatrixToPackedTexture(\n        this.gl, texture, rows, columns, matrix);\n  }\n\n  public downloadMatrixFromTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () =>\n            gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns));\n  }\n\n  public downloadMatrixFromPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () => gpgpu_util.downloadMatrixFromPackedOutputTexture(\n            this.gl, rows, columns));\n  }\n\n  public createProgram(fragmentShaderSource: string): WebGLProgram {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    const fragmentShader: WebGLShader =\n        webgl_util.createFragmentShader(gl, fragmentShaderSource);\n    const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl);\n    const program: WebGLProgram = webgl_util.createProgram(gl);\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader));\n    webgl_util.linkProgram(gl, program);\n    if (this.autoDebugValidate) {\n      webgl_util.validateProgram(gl, program);\n    }\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader));\n    return program;\n  }\n\n  public deleteProgram(program: WebGLProgram) {\n    this.throwIfDisposed();\n    if (program === this.program) {\n      this.program = null;\n    }\n    if (program != null) {\n      webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program));\n    }\n  }\n\n  public setProgram(program: WebGLProgram|null) {\n    this.throwIfDisposed();\n    this.program = program;\n    if ((this.program != null) && this.autoDebugValidate) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program));\n  }\n\n  public getUniformLocation(uniformName: string): WebGLUniformLocation {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    return webgl_util.getProgramUniformLocationOrThrow(\n        this.gl, this.program!, uniformName);\n  }\n\n  public setInputMatrixTexture(\n      inputMatrixTexture: WebGLTexture, uniformName: string,\n      textureUnit: number) {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    webgl_util.bindTextureToProgramUniformSampler(\n        this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit);\n  }\n\n  public setOutputMatrixTexture(\n      outputMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows);\n  }\n\n  public setOutputPackedMatrixTexture(\n      outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.throwIfDisposed();\n    const [width, height] =\n        tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n    this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height);\n  }\n\n  public setOutputMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    this.setOutputMatrixWriteRegionDriver(\n        startColumn, startRow, numColumns, numRows);\n  }\n\n  public setOutputPackedMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    throw new Error('setOutputPackedMatrixWriteRegion not implemented.');\n  }\n\n  public debugValidate() {\n    if (this.program != null) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.validateFramebuffer(this.gl);\n  }\n\n  public executeProgram() {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    const gl = this.gl;\n    gpgpu_util.bindVertexProgramAttributeStreams(\n        gl, this.program!, this.vertexBuffer);\n    if (this.autoDebugValidate) {\n      this.debugValidate();\n    }\n    webgl_util.callAndCheck(\n        gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0));\n  }\n\n  public blockUntilAllProgramsCompleted() {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(this.gl, () => this.gl.finish());\n  }\n\n  private downloadMatrixDriver(\n      texture: WebGLTexture,\n      downloadAndDecode: () => Float32Array): Float32Array {\n    this.throwIfDisposed();\n    webgl_util.bindColorTextureToFramebuffer(\n        this.gl, texture, this.framebuffer);\n    const result = downloadAndDecode();\n    if (this.outputTexture != null) {\n      webgl_util.bindColorTextureToFramebuffer(\n          this.gl, this.outputTexture, this.framebuffer);\n      if (this.autoDebugValidate) {\n        webgl_util.validateFramebuffer(this.gl);\n      }\n    } else {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n    }\n    return result;\n  }\n\n  private setOutputMatrixTextureDriver(\n      outputMatrixTextureMaybePacked: WebGLTexture, width: number,\n      height: number) {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    webgl_util.bindColorTextureToFramebuffer(\n        gl, outputMatrixTextureMaybePacked, this.framebuffer);\n    if (this.autoDebugValidate) {\n      webgl_util.validateFramebuffer(gl);\n    }\n    this.outputTexture = outputMatrixTextureMaybePacked;\n    webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height));\n    webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height));\n  }\n\n  private setOutputMatrixWriteRegionDriver(\n      x: number, y: number, width: number, height: number) {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(\n        this.gl, () => this.gl.scissor(x, y, width, height));\n  }\n\n  private throwIfDisposed() {\n    if (this.disposed) {\n      throw new Error('Attempted to use disposed GPGPUContext.');\n    }\n  }\n\n  private throwIfNoProgram() {\n    if (this.program == null) {\n      throw new Error('No GPU program is currently set.');\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nexport function getWebGLContextAttributes(): WebGLContextAttributes {\n  return {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: true\n  };\n}\n\nexport function createWebGLContext(canvas?: HTMLCanvasElement) {\n  const attributes = getWebGLContextAttributes();\n  let gl: WebGLRenderingContext;\n  if (canvas != null) {\n    gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes);\n  } else {\n    gl = webgl_util.createWebGLRenderingContext(attributes);\n  }\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE));\n  webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK));\n  return gl;\n}\n\nexport function createVertexShader(gl: WebGLRenderingContext): WebGLShader {\n  const vertexShaderSource = `\n    precision highp float;\n    attribute vec3 clipSpacePos;\n    attribute vec2 uv;\n    varying vec2 resultUV;\n\n    void main() {\n      gl_Position = vec4(clipSpacePos, 1);\n      resultUV = uv;\n    }`;\n  return webgl_util.createVertexShader(gl, vertexShaderSource);\n}\n\nexport function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // [x y z u v] * [upper-left, lower-left, upper-right, lower-right]\n  const vertexArray = new Float32Array(\n      [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]);\n  return webgl_util.createStaticVertexBuffer(gl, vertexArray);\n}\n\nexport function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // OpenGL (and WebGL) have \"CCW == front\" winding\n  const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]);\n  return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices);\n}\n\nfunction getTextureInternalFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled()) {\n    if (numChannels === 4) {\n      // tslint:disable-next-line:no-any\n      return (gl as any).RGBA32F;\n    }\n    // tslint:disable-next-line:no-any\n    return (gl as any).R32F;\n  }\n  return gl.RGBA;\n}\n\nfunction getTextureFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled() && numChannels === 1) {\n    // tslint:disable-next-line:no-any\n    return (gl as any).RED;\n  }\n  return gl.RGBA;\n}\n\nfunction createAndConfigureTexture(\n    gl: WebGLRenderingContext, width: number, height: number,\n    numChannels: number): WebGLTexture {\n  webgl_util.validateTextureSize(gl, width, height);\n  const texture = webgl_util.createTexture(gl);\n\n  const tex2d = gl.TEXTURE_2D;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  const format = getTextureFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n  return texture;\n}\n\nexport function createMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 1;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createColorMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createPackedMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function bindVertexProgramAttributeStreams(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    vertexBuffer: WebGLBuffer) {\n  const posOffset = 0;               // x is the first buffer element\n  const uvOffset = 3 * 4;            // uv comes after [x y z]\n  const stride = (3 * 4) + (2 * 4);  // xyz + uv, each entry is 4-byte float.\n  webgl_util.callAndCheck(\n      gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer));\n  webgl_util.bindVertexBufferToProgramAttribute(\n      gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset);\n  try {\n    webgl_util.bindVertexBufferToProgramAttribute(\n        gl, program, 'uv', vertexBuffer, 2, stride, uvOffset);\n  } catch (e) {\n    // Programs with 1x1 output textures don't use the uv attribute.\n    // This can cause the shader linker to dead-strip it, so we shouldn't\n    // complain or fail if it's not present.\n    if (!e.hasOwnProperty('namedVertexAttributeNotFound')) {\n      throw e;\n    }\n  }\n}\n\nexport function uploadPixelDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n  const numChannels = 4;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nfunction uploadDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, width: number,\n    height: number, data: Float32Array, numChannels: number) {\n  const textureFormat = getTextureFormat(gl, numChannels);\n\n  webgl_util.validateTextureSize(gl, width, height);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texSubImage2D(\n          gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT,\n          data));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function uploadMatrixToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array, numChannels: number) {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture =\n      numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n\n  uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels);\n}\n\nexport function uploadMatrixToPackedTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array) {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA);\n  const numChannels = 4;\n  uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels);\n}\n\nexport function downloadMatrixFromOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture = 4;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          rows * columns, channelsPerTexture));\n  const textureFormat = getTextureFormat(gl, channelsPerTexture);\n\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray));\n\n  const matrix = new Float32Array(rows * columns);\n  tex_util.decodeMatrixFromUnpackedArray(\n      unpackedArray, matrix, channelsPerTexture);\n  return matrix;\n}\n\nexport function downloadMatrixFromPackedOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA));\n  const matrix = new Float32Array(rows * columns);\n  return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          aMax = max(aMax, aCur);\n        }\n      }\n\n      float expSum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          expSum += exp(aCur - aMax);\n        }\n      }\n\n      gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n    }`;\n}\n\nexport function logSumExp(\n    gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(logSumExpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadLogSumExpDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result[0];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderMaxPoolBackprop(\n    dyShapeRCD: [number, number, number], fSize: number, origStride: number,\n    origPad: number) {\n  const origInputDepth = dyShapeRCD[2];\n  const pad = fSize - 1 - origPad;\n  const [dyRows, dyCols, depth] = dyShapeRCD;\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n    uniform sampler2D maxPos;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n      float dxR = dxTexCR.y;\n      float dxC = floor(dxTexCR.x / ${origInputDepth}.0);\n      float d = mod(dxTexCR.x, ${origInputDepth}.0);\n\n      vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0);\n      float dyRCorner = dyRCCorner.x;\n      float dyCCorner = dyRCCorner.y;\n\n      // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float dyR = (dyRCorner + wR) / ${origStride}.0;\n        // TODO(nsthorat): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) {\n          continue;\n        }\n\n        float dyTexR = dyR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float dyC = (dyCCorner + wC) / ${origStride}.0;\n          if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) {\n            continue;\n          }\n\n          float dyTexC = dyC * ${depth}.0 + d;\n\n          // Read dy(dyR, dyC, d).\n          vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read maxPos(dyR, dyC, d).\n          float maxPosValue =\n              ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r;\n\n          // Get the current value, check it against the value from the\n          // position matrix.\n          float curPosValue = wR * ${fSize}.0 + wC;\n          float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n          dotProd += dyValue * mask;\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function maxPoolBackprop(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    maxPositionsTex: WebGLTexture, resultTex: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMaxPoolPositionsSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, true);\n}\n\nexport function getFragmentShaderMaxPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, false);\n}\n\nfunction getFragmentShaderMaxPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, computeMaxPositions: boolean) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions);\n}\n\nexport function maxPoolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\nimport {Array2D} from '../ndarray';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as shader_compiler from './shader_compiler';\n\nexport function getFragmentShader(\n    a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  const sharedDim =\n      (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]);\n  const aSnippet =\n      (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow';\n  const bSnippet =\n      (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i';\n\n  const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}];\n  const userCode = `\n    const float sharedDim = ${sharedDim}.0;\n\n    float dotARowBCol(float aRow, float bCol) {\n      float result = 0.0;\n      for (float i = 0.0; i < sharedDim; i += 1.0) {\n        float a = getMatrixA(${aSnippet});\n        float b = getMatrixB(${bSnippet});\n        result += (a * b);\n      }\n      return result;\n    }\n\n    void main() {\n      vec2 resRC = getOutputCoords();\n      setOutput(dotARowBCol(resRC.x, resRC.y));\n    }\n  `;\n  return shader_compiler.makeShader(inputs, out, userCode);\n}\n\nexport function multiplyMatrix(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    sharedDimension: number, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  /*\n      A = [0 1   B = [0 1  out = [A0*B0+A1*B2 A0*B1+A1*B3\n           2 3]       2 3]        A2*B0+A1*B2 A2*B1+Aw*B3]\n      out.0 = A0 * B0 + A1 * B2\n      out.1 = A0 * B1 + A1 * B3\n      out.2 = A2 * B0 + A3 * B2\n      out.3 = A2 * B1 + A3 * B3\n\n      A*B     = A.xxzz * B.xyxy + A.yyww * B.zwzw\n      A^t*B   = A.xxyy * B.xyxy + A.zzww * B.zwzw\n      A*B^t   = A.xxzz * B.xzxz + A.yyww * B.ywyw\n      A^t*B^t = A.xxyy * B.xzxz + A.zzww * B.ywyw\n   */\n  const sharedDimensionPacked = Math.ceil(sharedDimension / 2);\n  const aSample = (aOrientation === MatrixOrientation.REGULAR) ?\n      'center, resultUV.t' :\n      'resultUV.t, center';\n  const bSample = (bOrientation === MatrixOrientation.REGULAR) ?\n      'resultUV.s, center' :\n      'center, resultUV.s';\n  const aSwizzle: [string, string] =\n      (aOrientation === MatrixOrientation.REGULAR) ? ['a.xxzz', 'a.yyww'] :\n                                                     ['a.xxyy', 'a.zzww'];\n  const bSwizzle: [string, string] =\n      (bOrientation === MatrixOrientation.REGULAR) ? ['b.xyxy', 'b.zwzw'] :\n                                                     ['b.xzxz', 'b.ywyw'];\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;\n\n    const float sharedDimension = ${sharedDimensionPacked}.0;\n\n    vec4 dot2x2ARowBCol() {\n      vec4 result = vec4(0, 0, 0, 0);\n      for (float i = 0.0; i < sharedDimension; i += 1.0) {\n        float center = (i + 0.5) / sharedDimension;\n        vec4 a = texture2D(matrixA, vec2(${aSample}));\n        vec4 b = texture2D(matrixB, vec2(${bSample}));\n        result +=\n          (${aSwizzle[0]} * ${bSwizzle[0]}) + (${aSwizzle[1]} * ${bSwizzle[1]});\n      }\n      return result;\n    }\n\n    void main() {\n      gl_FragColor = dot2x2ARowBCol();\n    }`;\n}\n\nexport function multiplyMatrixPacked(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputPackedMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n\nexport function uploadMultiplyMatrixPackedDownload(\n    a: Float32Array, aShapeRowCol: [number, number], b: Float32Array,\n    bShapeRowCol: [number, number], aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const resultNumRows = (aOrientation === MatrixOrientation.REGULAR) ?\n      aShapeRowCol[0] :\n      aShapeRowCol[1];\n  const resultNumCols = (bOrientation === MatrixOrientation.REGULAR) ?\n      bShapeRowCol[1] :\n      bShapeRowCol[0];\n  const sharedDimension = (aOrientation === MatrixOrientation.REGULAR) ?\n      aShapeRowCol[1] :\n      aShapeRowCol[0];\n\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram = gpgpu.createProgram(\n      getFragmentShaderSource(sharedDimension, aOrientation, bOrientation));\n\n  const aTexture: WebGLTexture =\n      gpgpu.createPackedMatrixTexture(aShapeRowCol[0], aShapeRowCol[1]);\n  const bTexture: WebGLTexture =\n      gpgpu.createPackedMatrixTexture(bShapeRowCol[0], bShapeRowCol[1]);\n  const resultTexture: WebGLTexture =\n      gpgpu.createPackedMatrixTexture(resultNumRows, resultNumCols);\n\n  gpgpu.uploadMatrixToPackedTexture(\n      aTexture, aShapeRowCol[0], aShapeRowCol[1], a);\n  gpgpu.uploadMatrixToPackedTexture(\n      bTexture, bShapeRowCol[0], bShapeRowCol[1], b);\n\n  multiplyMatrixPacked(\n      gpgpu, program, aTexture, bTexture, resultTexture,\n      [resultNumRows, resultNumCols]);\n\n  const result = gpgpu.downloadMatrixFromPackedTexture(\n      resultTexture, resultNumRows, resultNumCols);\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) {\n  if (poolType === 'avg' && computePositions) {\n    throw new Error('Cannot compute positions for average pool.');\n  }\n\n  const depth = xShapeRCD[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n\n  let returnValue = 'minMaxValue';\n  if (computePositions) {\n    returnValue = 'minMaxPosition';\n  } else if (poolType === 'avg') {\n    returnValue = 'avgValue';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    varying vec2 resultUV;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${depth}.0);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // max/min x(?, ?, d) to get y(yR, yC, d).\n      // ? = to be determined\n      float minMaxValue = 0.0;\n      float minMaxValueFound = 0.0;\n      float minMaxPosition = 0.0;\n      float avgValue = 0.0;\n\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n          float xTexC = xC * ${depth}.0 + d;\n\n          vec2 texCR = vec2(xTexC, xTexR);\n\n          // Check if the requested UV is invalid.\n          vec2 uv = (texCR + halfCR) / xShapeCR;\n          bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n          bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n          bool outside = lessThanZero || greaterThanOne;\n          if (outside) {\n            continue;\n          }\n\n          float value = texture2D(x, uv).r;\n          if (isNaN(value)) {\n            gl_FragColor = vec4(value, 0, 0, 0);\n            return;\n          }\n          if (${poolType === 'avg'}) {\n            avgValue += value / ${fSize * fSize}.0;\n          } else {\n            // If a min / max value has already been found, use it. If not, use\n            // the current value.\n            float currentMinMaxValue = mix(\n                value, minMaxValue, minMaxValueFound);\n            if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) {\n              minMaxValue = value;\n              minMaxValueFound = 1.0;\n              if (${computePositions}) {\n                minMaxPosition = wR * ${fSize}.0 + wC;\n              }\n            }\n          }\n        }\n      }\n      gl_FragColor = vec4(${returnValue}, 0, 0, 0);\n    }`;\n}\n\nexport function poolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {NDArray} from '../ndarray';\n\nexport type Input = {\n  name: string; array: NDArray;\n};\n\nexport function makeShaderKey(inputs: NDArray[], output: NDArray): string {\n  const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC());\n  return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC();\n}\n\nexport function makeShader(\n    inputs: Input[], output: NDArray, userCode: string): string {\n  const inputPrefixSnippet =\n      inputs.map(x => `uniform sampler2D ${x.name};`).join('\\n');\n  const inputSamplingSnippet =\n      inputs.map(x => getInputSamplingSnippet(x)).join('\\n');\n  const outTexShape = output.getTextureShapeRC();\n  const outputSamplingSnippet =\n      getOutputSamplingSnippet(output.shape, outTexShape);\n  const source = [\n    SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet,\n    outputSamplingSnippet, userCode\n  ].join('\\n');\n  return source;\n}\n\nfunction getInputSamplingSnippet(input: Input) {\n  const arr = input.array;\n  const shape = arr.shape;\n  const texShape = arr.getTextureShapeRC(shape as [number, number]);\n  switch (shape.length) {\n    case 2:\n      return getSampler2D(input.name, shape as [number, number], texShape);\n    default:\n      throw new Error(`${arr.rank}-D input sampling is not yet supported`);\n  }\n}\n\nfunction getOutputSamplingSnippet(\n    outShape: number[], outTexShape: [number, number]): string {\n  switch (outShape.length) {\n    case 2:\n      return getOutput2DCoords(outShape as [number, number], outTexShape);\n    default:\n      throw new Error(\n          `${outShape.length}-D output sampling is not yet supported`);\n  }\n}\n\nconst SHADER_PREFIX = `\n  precision highp float;\n  varying vec2 resultUV;\n  const vec2 halfCR = vec2(0.5, 0.5);\n\n  void setOutput(float val) {\n    gl_FragColor = vec4(val, 0, 0, 0);\n  }\n`;\n\nconst SAMPLE_2D_SNIPPET = `\n  float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n      float row, float col) {\n    float index = dot(vec2(row, col), vec2(numC, 1.0));\n    float texR = floor(index / texNumC);\n    float texC = mod(index, texNumC);\n    vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n    return texture2D(texture, uv).r;\n  }\n`;\n\nfunction getOutput2DCoords(\n    shape: [number, number], texShape: [number, number]) {\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      vec2 getOutputCoords() {\n        return floor(gl_FragCoord.yx);\n      }\n    `;\n  }\n  return `\n    vec2 getOutputCoords() {\n      vec2 resTexRC = floor(gl_FragCoord.yx);\n      float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0));\n      float r = floor(index / ${shape[1]}.0);\n      float c = mod(index, ${shape[1]}.0);\n      return vec2(r, c);\n    }\n  `;\n}\n\nfunction getSampler2D(\n    texName: string, shape: [number, number], texShape: [number, number]) {\n  const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1);\n  const tR = texShape[0];\n  const tC = texShape[1];\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      float ${funcName}(float row, float col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0);\n        return texture2D(${texName}, uv).r;\n      }\n    `;\n  }\n  return `\n    float ${funcName}(float row, float col) {\n      return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col);\n    }\n  `;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getUnpackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns, rows];\n}\n\nexport function getUnpackedArraySizeFromMatrixSize(\n    matrixSize: number, channelsPerTexture: number): number {\n  return matrixSize * channelsPerTexture;\n}\n\nexport function getColorMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns * 4, rows];\n}\n\nexport function getMatrixSizeFromUnpackedArraySize(\n    unpackedSize: number, channelsPerTexture: number): number {\n  if (unpackedSize % channelsPerTexture !== 0) {\n    throw new Error(\n        'unpackedSize (' + unpackedSize + ') must be a multiple of ' +\n        channelsPerTexture);\n  }\n  return unpackedSize / channelsPerTexture;\n}\n\nexport function encodeMatrixToUnpackedArray(\n    matrix: Float32Array, unpackedArray: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize =\n      getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);\n  if (unpackedArray.length < requiredSize) {\n    throw new Error(\n        'unpackedArray length (' + unpackedArray.length +\n        ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < matrix.length; ++src) {\n    unpackedArray[dst] = matrix[src];\n    dst += channelsPerTexture;\n  }\n}\n\nexport function decodeMatrixFromUnpackedArray(\n    unpackedArray: Float32Array, matrix: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize = getMatrixSizeFromUnpackedArraySize(\n      unpackedArray.length, channelsPerTexture);\n  if (matrix.length < requiredSize) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) {\n    matrix[dst++] = unpackedArray[src];\n  }\n}\n\nexport function getPackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [Math.ceil(columns / 2), Math.ceil(rows / 2)];\n}\n\nexport function getPackedRGBAArraySizeFromMatrixShape(\n    rows: number, columns: number): number {\n  const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  return w * h * 4;\n}\n\nexport function encodeMatrixToPackedRGBA(\n    matrix: Float32Array, rows: number, columns: number,\n    packedRGBA: Float32Array) {\n  const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);\n  if (packedRGBA.length < requiredSize) {\n    throw new Error(\n        'packedRGBA length (' + packedRGBA.length +\n        ') must be >= ' + requiredSize);\n  }\n  /*\n    Unpacked matrix, row-major order in Float32Array[16]:  A B C D\n                                                           E F G H\n                                                           I J K L\n                                                           M N O P\n\n    Packed matrix, 2x2 RGBA32 texture (memory view):       ABEF CDGH IJMN KLOP\n\n    Packed matrix, 2x2 RGBA32 texture (matrix view):       AB|CD\n                                                           EF|GH\n                                                           --+--\n                                                           IJ|KL\n                                                           MN|OP\n   */\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n\n  // loop over full 2x2 blocks\n  {\n    const dstStride = (oddWidth ? 4 : 0);\n    const oneRow = columns;\n    let dst = 0;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      const matrixSrcRow = (blockY * 2 * columns);\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        const matrixSrcCol = blockX * 2;\n        const src = matrixSrcRow + matrixSrcCol;\n        packedRGBA[dst] = matrix[src];\n        packedRGBA[dst + 1] = matrix[src + 1];\n        packedRGBA[dst + 2] = matrix[src + oneRow];\n        packedRGBA[dst + 3] = matrix[src + oneRow + 1];\n        dst += 4;\n      }\n      dst += dstStride;\n    }\n  }\n\n  // loop down final odd column\n  if (oddWidth) {\n    let src = columns - 1;\n    let dst = (textureWidth - 1) * 4;\n    const srcStride = 2 * columns;\n    const dstStride = textureWidth * 4;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      packedRGBA[dst] = matrix[src];\n      packedRGBA[dst + 2] = matrix[src + columns];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (rows - 1) * columns;\n    let dst = (textureHeight - 1) * textureWidth * 4;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      packedRGBA[dst++] = matrix[src++];\n      packedRGBA[dst++] = matrix[src++];\n      dst += 2;\n    }\n  }\n\n  // fill in bottom-right texel\n  if (oddWidth && oddHeight) {\n    packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];\n  }\n\n  return packedRGBA;\n}\n\nexport function decodeMatrixFromPackedRGBA(\n    packedRGBA: Float32Array, rows: number, columns: number,\n    matrix: Float32Array): Float32Array {\n  const requiredSize = rows * columns;\n  if (requiredSize < matrix.length) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  // loop over full 2x2 blocks\n  {\n    const srcStride = oddWidth ? 4 : 0;\n    const dstStride = columns + (oddWidth ? 1 : 0);\n    let src = 0;\n    let dstRow1 = 0;\n    let dstRow2 = columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n      }\n      src += srcStride;\n      dstRow1 += dstStride;\n      dstRow2 += dstStride;\n    }\n  }\n\n  // loop down final column\n  if (oddWidth) {\n    let src = (textureWidth - 1) * 4;\n    let dst = columns - 1;\n    const srcStride = textureWidth * 4;\n    const dstStride = 2 * columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      matrix[dst] = packedRGBA[src];\n      matrix[dst + columns] = packedRGBA[src + 2];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (textureHeight - 1) * textureWidth * 4;\n    let dst = (rows - 1) * columns;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      matrix[dst++] = packedRGBA[src++];\n      matrix[dst++] = packedRGBA[src++];\n      src += 2;\n    }\n  }\n\n  // fill in bottom-right cell\n  if (oddWidth && oddHeight) {\n    matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];\n  }\n\n  return matrix;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nlet USE_WEBGL2_WHEN_AVAILABLE = false;\nlet WEBGL2_ENABLED: boolean|undefined = null!;\nlet MAX_TEXTURE_SIZE: number = null!;\n\nimport * as util from '../../util';\n\nexport interface WebGLContextAttributes {\n  alpha?: boolean;\n  antialias?: boolean;\n  premultipliedAlpha?: boolean;\n  preserveDrawingBuffer?: boolean;\n  depth?: boolean;\n  stencil?: boolean;\n  failIfMajorPerformanceCaveat?: boolean;\n}\n\n/** @hidden */\nexport const IS_NAN_SHADER_FUNC = `\nbool isNaN(float val) {\n  return val == val ? false : true;\n}\n`;\n\nexport interface WebGLLoseContextExtension { loseContext(): void; }\n\nexport function createWebGLRenderingContext(attributes: WebGLContextAttributes):\n    WebGLRenderingContext {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return createWebGLRenderingContextFromCanvas(canvas, attributes);\n}\n\n/**\n * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL\n * 2.0 is available.\n */\nexport function preferWebGL1() {\n  USE_WEBGL2_WHEN_AVAILABLE = false;\n  WEBGL2_ENABLED = undefined;\n}\n\n/**\n * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration.\n */\nexport function preferWebGL2() {\n  USE_WEBGL2_WHEN_AVAILABLE = true;\n  WEBGL2_ENABLED = undefined;\n}\n\nexport function isWebGL2Enabled() {\n  if (!USE_WEBGL2_WHEN_AVAILABLE) {\n    return false;\n  }\n\n  if (WEBGL2_ENABLED === undefined) {\n    const tempCanvas = document.createElement('canvas');\n    const gl = tempCanvas.getContext('webgl2');\n    if (gl != null) {\n      WEBGL2_ENABLED = true;\n\n      const loseContextExtension =\n          getExtensionOrThrow(\n              gl as WebGLRenderingContext, 'WEBGL_lose_context') as\n          WebGLLoseContextExtension;\n      loseContextExtension.loseContext();\n    } else {\n      WEBGL2_ENABLED = false;\n    }\n  }\n  return WEBGL2_ENABLED;\n}\n\nexport function createWebGLRenderingContextFromCanvas(\n    canvas: HTMLCanvasElement,\n    attributes: WebGLContextAttributes): WebGLRenderingContext {\n  let gl: WebGLRenderingContext;\n  if (isWebGL2Enabled()) {\n    gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext;\n  } else {\n    gl = (canvas.getContext('webgl', attributes) ||\n          canvas.getContext('experimental-webgl', attributes)) as\n        WebGLRenderingContext;\n  }\n\n  if (gl == null) {\n    throw new Error('This browser does not support WebGL.');\n  }\n  return gl;\n}\n\nexport function callAndCheck<T>(gl: WebGLRenderingContext, func: () => T): T {\n  const returnValue = func();\n  checkWebGLError(gl);\n  return returnValue;\n}\n\nlet webGLDebugErrorCheckingEnabled = false;\n\nexport function enableDebugWebGLErrorChecking(enabled: boolean) {\n  webGLDebugErrorCheckingEnabled = enabled;\n}\n\nexport function checkWebGLError(gl: WebGLRenderingContext) {\n  if (webGLDebugErrorCheckingEnabled) {\n    const error = gl.getError();\n    if (error !== gl.NO_ERROR) {\n      throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error));\n    }\n  }\n}\n\nexport function getWebGLErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.NO_ERROR:\n      return 'NO_ERROR';\n    case gl.INVALID_ENUM:\n      return 'INVALID_ENUM';\n    case gl.INVALID_VALUE:\n      return 'INVALID_VALUE';\n    case gl.INVALID_OPERATION:\n      return 'INVALID_OPERATION';\n    case gl.INVALID_FRAMEBUFFER_OPERATION:\n      return 'INVALID_FRAMEBUFFER_OPERATION';\n    case gl.OUT_OF_MEMORY:\n      return 'OUT_OF_MEMORY';\n    case gl.CONTEXT_LOST_WEBGL:\n      return 'CONTEXT_LOST_WEBGL';\n    default:\n      return 'Unknown error code ' + status;\n  }\n}\n\nexport function getExtensionOrThrow(\n    gl: WebGLRenderingContext, extensionName: string): {} {\n  return throwIfNull<{}>(\n      gl, () => gl.getExtension(extensionName),\n      'Extension \"' + extensionName + '\" not supported on this browser.');\n}\n\nexport function createVertexShader(\n    gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader {\n  const vertexShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.VERTEX_SHADER),\n      'Unable to create vertex WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource));\n  callAndCheck(gl, () => gl.compileShader(vertexShader));\n  if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(vertexShader));\n    throw new Error('Failed to compile vertex shader.');\n  }\n  return vertexShader;\n}\n\nexport function createFragmentShader(\n    gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader {\n  const fragmentShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.FRAGMENT_SHADER),\n      'Unable to create fragment WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource));\n  callAndCheck(gl, () => gl.compileShader(fragmentShader));\n  if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(fragmentShader));\n    throw new Error('Failed to compile fragment shader.');\n  }\n  return fragmentShader;\n}\n\nexport function createProgram(gl: WebGLRenderingContext): WebGLProgram {\n  return throwIfNull<WebGLProgram>(\n      gl, () => gl.createProgram(), 'Unable to create WebGLProgram.');\n}\n\nexport function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.linkProgram(program));\n  if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Failed to link vertex and fragment shaders.');\n  }\n}\n\nexport function validateProgram(\n    gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.validateProgram(program));\n  if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Shader program validation failed.');\n  }\n}\n\nexport function createStaticVertexBuffer(\n    gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function createStaticIndexBuffer(\n    gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function queryMaxTextureSize(gl: WebGLRenderingContext): number {\n  if (MAX_TEXTURE_SIZE != null) {\n    return MAX_TEXTURE_SIZE;\n  }\n  MAX_TEXTURE_SIZE =\n      callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE));\n  return MAX_TEXTURE_SIZE;\n}\n\nexport function getChannelsPerTexture(): number {\n  if (isWebGL2Enabled()) {\n    return 1;\n  }\n  return 4;\n}\n\nexport function createTexture(gl: WebGLRenderingContext): WebGLTexture {\n  return throwIfNull<WebGLTexture>(\n      gl, () => gl.createTexture(), 'Unable to create WebGLTexture.');\n}\n\nexport function validateTextureSize(\n    gl: WebGLRenderingContext, width: number, height: number) {\n  const maxTextureSize: number = queryMaxTextureSize(gl);\n  if ((width <= 0) || (height <= 0)) {\n    const requested = '[' + width + 'x' + height + ']';\n    throw new Error('Requested texture size ' + requested + ' is invalid.');\n  }\n  if ((width > maxTextureSize) || (height > maxTextureSize)) {\n    const requested = '[' + width + 'x' + height + ']';\n    const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']';\n    throw new Error(\n        'Requested texture size ' + requested +\n        ' greater than WebGL maximum on this browser / GPU ' + max + '.');\n  }\n}\n\nexport function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer {\n  return throwIfNull<WebGLFramebuffer>(\n      gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.');\n}\n\nexport function bindVertexBufferToProgramAttribute(\n    gl: WebGLRenderingContext, program: WebGLProgram, attribute: string,\n    buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number,\n    itemOffsetInBytes: number) {\n  const loc = gl.getAttribLocation(program, attribute);\n  if (loc === -1) {\n    const error = new Error(\n        'Unable to get attribute \"' + attribute + '\" on WebGLProgram.');\n    // tslint:disable-next-line:no-any\n    (error as any).namedVertexAttributeNotFound = attribute;\n    throw error;\n  }\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl,\n      () => gl.vertexAttribPointer(\n          loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes,\n          itemOffsetInBytes));\n  callAndCheck(gl, () => gl.enableVertexAttribArray(loc));\n}\n\nexport function bindTextureUnit(\n    gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n}\n\nexport function unbindTextureUnit(\n    gl: WebGLRenderingContext, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function getProgramUniformLocationOrThrow(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    uniformName: string): WebGLUniformLocation {\n  return throwIfNull<WebGLUniformLocation>(\n      gl, () => gl.getUniformLocation(program, uniformName),\n      'uniform \"' + uniformName + '\" not present in program.');\n}\n\nexport function bindTextureToProgramUniformSampler(\n    gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture,\n    uniformSamplerName: string, textureUnit: number) {\n  callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit));\n  const samplerLocation =\n      getProgramUniformLocationOrThrow(gl, program, uniformSamplerName);\n  callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit));\n}\n\nexport function bindCanvasToFramebuffer(gl: WebGLRenderingContext) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n  callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height));\n  callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height));\n}\n\nexport function bindColorTextureToFramebuffer(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0));\n}\n\nexport function unbindColorTextureFromFramebuffer(\n    gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0));\n}\n\nexport function validateFramebuffer(gl: WebGLRenderingContext) {\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new Error(\n        'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status));\n  }\n}\n\nexport function getFramebufferErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n      return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS';\n    case gl.FRAMEBUFFER_UNSUPPORTED:\n      return 'FRAMEBUFFER_UNSUPPORTED';\n    default:\n      return 'unknown error ' + status;\n  }\n}\n\nfunction throwIfNull<T>(\n    gl: WebGLRenderingContext, returnTOrNull: () => T | null,\n    failureMessage: string): T {\n  const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull());\n  if (tOrNull == null) {\n    throw new Error(failureMessage);\n  }\n  return tOrNull as T;\n}\n\nfunction validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) {\n  const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;\n  const glTextureUnit = textureUnit + gl.TEXTURE0;\n  if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) {\n    const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']';\n    throw new Error('textureUnit must be in ' + textureUnitRange + '.');\n  }\n}\n\nexport function getTextureShapeFromLogicalShape(\n    gl: WebGLRenderingContext, logicalShape: number[],\n    preferredTexShape?: [number, number]): [number, number] {\n  const maxTexSize = queryMaxTextureSize(gl);\n  const size = util.sizeFromShape(logicalShape);\n  if (preferredTexShape != null) {\n    const sizePreferred = util.sizeFromShape(preferredTexShape);\n    util.assert(\n        size === sizePreferred,\n        `Size of shape (${size}) must match size of ` +\n            `preferredShape (${sizePreferred})`);\n    if (preferredTexShape[0] <= maxTexSize &&\n        preferredTexShape[1] <= maxTexSize) {\n      return preferredTexShape;\n    }\n  }\n\n  if (logicalShape.length <= 1 && size <= maxTexSize) {\n    return [size, 1];\n  } else if (\n      logicalShape.length === 2 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] <= maxTexSize) {\n    return logicalShape as [number, number];\n  } else if (\n      logicalShape.length === 3 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] * logicalShape[2] <= maxTexSize) {\n    return [logicalShape[0], logicalShape[1] * logicalShape[2]];\n  } else {\n    return util.sizeToSquarishShape(size);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function expectArraysClose(\n    actual: Float32Array, expected: Float32Array, epsilon: number) {\n  if (actual.length !== expected.length) {\n    throw new Error(\n        'Matrices have different lengths (' + actual.length + ' vs ' +\n        expected.length + ').');\n  }\n  for (let i = 0; i < expected.length; ++i) {\n    const a = actual[i];\n    const e = expected[i];\n    if (isNaN(a) && isNaN(e)) {\n      continue;\n    }\n    if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon) {\n      const actualStr = 'actual[' + i + '] === ' + a;\n      const expectedStr = 'expected[' + i + '] === ' + e;\n      throw new Error('Arrays differ: ' + actualStr + ', ' + expectedStr);\n    }\n  }\n}\n\nexport function randomArrayInRange(\n    n: number, minValue: number, maxValue: number): Float32Array {\n  const v = new Float32Array(n);\n  const range = maxValue - minValue;\n  for (let i = 0; i < n; ++i) {\n    v[i] = (Math.random() * range) + minValue;\n  }\n  return v;\n}\n\nexport function makeIdentity(n: number): Float32Array {\n  const i = new Float32Array(n * n);\n  for (let j = 0; j < n; ++j) {\n    i[(j * n) + j] = 1;\n  }\n  return i;\n}\n\nexport function setValue(\n    m: Float32Array, mNumRows: number, mNumCols: number, v: number, row: number,\n    column: number) {\n  if (row >= mNumRows) {\n    throw new Error('row (' + row + ') must be in [0 ' + mNumRows + '].');\n  }\n  if (column >= mNumCols) {\n    throw new Error('column (' + column + ') must be in [0 ' + mNumCols + '].');\n  }\n  m[(row * mNumCols) + column] = v;\n}\n\nexport function cpuMultiplyMatrix(\n    a: Float32Array, aRow: number, aCol: number, b: Float32Array, bRow: number,\n    bCol: number) {\n  const result = new Float32Array(aRow * bCol);\n  for (let r = 0; r < aRow; ++r) {\n    for (let c = 0; c < bCol; ++c) {\n      let d = 0;\n      for (let k = 0; k < aCol; ++k) {\n        d += a[(r * aCol) + k] * b[(k * bCol) + c];\n      }\n      result[(r * bCol) + c] = d;\n    }\n  }\n  return result;\n}\n\nexport function cpuDotProduct(a: Float32Array, b: Float32Array): number {\n  if (a.length !== b.length) {\n    throw new Error('cpuDotProduct: incompatible vectors.');\n  }\n  let d = 0;\n  for (let i = 0; i < a.length; ++i) {\n    d += a[i] * b[i];\n  }\n  return d;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport type Vector = number[] | Float64Array | Float32Array | Int32Array |\n    Int8Array | Int16Array;\n\n/** Shuffles the array using Fisher-Yates algorithm. */\n// tslint:disable-next-line:no-any\nexport function shuffle(array: any[]|Uint32Array|Int32Array|\n                        Float32Array): void {\n  let counter = array.length;\n  let temp = 0;\n  let index = 0;\n  // While there are elements in the array\n  while (counter > 0) {\n    // Pick a random index\n    index = (Math.random() * counter) | 0;\n    // Decrease counter by 1\n    counter--;\n    // And swap the last element with it\n    temp = array[counter];\n    array[counter] = array[index];\n    array[index] = temp;\n  }\n}\n\n/** Clamps a value to a specified range. */\nexport function clamp(min: number, x: number, max: number): number {\n  return Math.max(min, Math.min(x, max));\n}\n\n/** Returns a sample from a uniform [a, b] distribution. */\nexport function randUniform(a: number, b: number) {\n  return Math.random() * (b - a) + a;\n}\n\n/**\n * Samples from a gaussian distribution.\n *\n * @param mean The mean. Default is 0.\n * @param stdDev The standard deviation. Default is 1.\n */\nexport function randGauss(mean = 0, stdDev = 1, truncated = false): number {\n  let v1: number, v2: number, s: number;\n  do {\n    v1 = 2 * Math.random() - 1;\n    v2 = 2 * Math.random() - 1;\n    s = v1 * v1 + v2 * v2;\n  } while (s > 1);\n\n  const result = Math.sqrt(-2 * Math.log(s) / s) * v1;\n  if (truncated && result > 2) {\n    return randGauss(mean, stdDev, true);\n  }\n  return mean + stdDev * result;\n}\n\n/** Returns squared eucledian distance between two vectors. */\nexport function distSquared(a: Vector, b: Vector): number {\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    const diff = a[i] - b[i];\n    result += diff * diff;\n  }\n  return result;\n}\n\nexport function assert(expr: boolean, msg: string) {\n  if (!expr) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertShapesMatch(\n    shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void {\n  assert(\n      arraysEqual(shapeA, shapeB),\n      errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`);\n}\n\n// tslint:disable-next-line:no-any\nexport function flatten(arr: any[], ret?: number[]): number[] {\n  ret = (ret === undefined ? [] : ret);\n  for (let i = 0; i < arr.length; ++i) {\n    if (Array.isArray(arr[i])) {\n      flatten(arr[i], ret);\n    } else {\n      ret.push(arr[i]);\n    }\n  }\n  return ret;\n}\n\nexport type ArrayData = number|number[]|number[][]|number[][][]|number[][][][];\n\nexport function inferShape(arr: ArrayData): number[] {\n  const shape: number[] = [];\n  while (arr instanceof Array) {\n    shape.push(arr.length);\n    arr = arr[0];\n  }\n  return shape;\n}\n\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\n\nexport function isScalarShape(shape: number[]): boolean {\n  return shape.length === 0;\n}\n\n// tslint:disable-next-line:no-any\nexport function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) {\n  if (n1.length !== n2.length) {\n    return false;\n  }\n  for (let i = 0; i < n1.length; i++) {\n    if (n1[i] !== n2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\n\nexport function tanh(x: number): number {\n  // tslint:disable-next-line:no-any\n  if ((Math as any).tanh != null) {\n    // tslint:disable-next-line:no-any\n    return (Math as any).tanh(x);\n  }\n  if (x === Infinity) {\n    return 1;\n  } else if (x === -Infinity) {\n    return -1;\n  } else {\n    const e2x = Math.exp(2 * x);\n    return (e2x - 1) / (e2x + 1);\n  }\n}\n\nexport function sizeToSquarishShape(size: number): [number, number] {\n  for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) {\n    if (size % a === 0) {\n      return [a, size / a];\n    }\n  }\n  return [1, size];\n}\n\nexport function createShuffledIndices(n: number): Uint32Array {\n  const shuffledIndices = new Uint32Array(n);\n  for (let i = 0; i < n; ++i) {\n    shuffledIndices[i] = i;\n  }\n  shuffle(shuffledIndices);\n  return shuffledIndices;\n}\n"]} diff --git a/demos/benchmarks/conv_gpu_benchmark.ts b/demos/benchmarks/conv_gpu_benchmark.ts new file mode 100644 index 0000000000..fffd644e2c --- /dev/null +++ b/demos/benchmarks/conv_gpu_benchmark.ts @@ -0,0 +1,90 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../../src/math/conv_util'; +import * as conv_gpu from '../../src/math/webgl/conv_gpu'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 40; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const inputShapeRCD: [number, number, number] = [size, size, 1]; + const outputDepth = 1; + const fieldSize = 11; + const stride = 1; + const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride); + const outputShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + inputShapeRCD, fieldSize, outputDepth, stride, zeroPad); + + const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + const weightsTexShapeRC = conv_util.computeWeightsTexShape( + inputShapeRCD[2], outputDepth, fieldSize); + const biasesTexShapeRC = conv_util.computeBiasesTexShape(outputDepth); + + const hasBias = true; + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram(conv_gpu.getFragmentShaderSource( + inputShapeRCD, outputDepth, fieldSize, stride, zeroPad, hasBias)); + + const inputTexture = + gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]); + const weightsTexture = + gpgpu.createMatrixTexture(weightsTexShapeRC[0], weightsTexShapeRC[1]); + const biasesTexture = + gpgpu.createMatrixTexture(biasesTexShapeRC[0], biasesTexShapeRC[1]); + const outputTexture = + gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + + const inputData = test_util.randomArrayInRange( + inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1); + const weightsData = test_util.randomArrayInRange( + weightsTexShapeRC[0] * weightsTexShapeRC[1], -1, 1); + const biasesData = test_util.randomArrayInRange( + biasesTexShapeRC[0] * biasesTexShapeRC[1], -1, 1); + + gpgpu.uploadMatrixToTexture( + inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData); + gpgpu.uploadMatrixToTexture( + weightsTexture, weightsTexShapeRC[0], weightsTexShapeRC[1], weightsData); + gpgpu.uploadMatrixToTexture( + biasesTexture, biasesTexShapeRC[0], biasesTexShapeRC[1], biasesData); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + conv_gpu.convolve( + gpgpu, program, inputTexture, weightsTexture, biasesTexture, + outputTexture, outputTexShapeRC); + } + + gpgpu.downloadMatrixFromTexture( + outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + const end = performance.now(); + + const avgTime = (end - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(inputTexture); + gpgpu.deleteMatrixTexture(weightsTexture); + gpgpu.deleteMatrixTexture(biasesTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; diff --git a/demos/benchmarks/conv_transpose_gpu_benchmark.ts b/demos/benchmarks/conv_transpose_gpu_benchmark.ts new file mode 100644 index 0000000000..dcc26f67e8 --- /dev/null +++ b/demos/benchmarks/conv_transpose_gpu_benchmark.ts @@ -0,0 +1,85 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../../src/math/conv_util'; +import * as conv_backprop_gpu from '../../src/math/webgl/conv_backprop_gpu'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 100; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const xShapeRCD: [number, number, number] = [size, size, 1]; + const origOutputDepth = 2; + const fieldSize = 11; + const origStride = 1; + const origPad = 1; + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + const origInputDepth = xShapeRCD[2]; + const src = conv_backprop_gpu.getFragmentShaderConvTransposeSource( + xShapeRCD, fieldSize, origInputDepth, origStride, origPad, false); + const program = gpgpu.createProgram(src); + + // Upload x. + const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + const xData = + test_util.randomArrayInRange(xTexShapeRC[0] * xTexShapeRC[1], -1, 1); + gpgpu.uploadMatrixToTexture(xTex, xTexShapeRC[0], xTexShapeRC[1], xData); + + // Upload weights. + const wTexShapeRC = conv_util.computeWeightsTexShape( + origInputDepth, origOutputDepth, fieldSize); + const wData = + test_util.randomArrayInRange(wTexShapeRC[0] * wTexShapeRC[1], -1, 1); + const wTex = gpgpu.createMatrixTexture(wTexShapeRC[0], wTexShapeRC[1]); + gpgpu.uploadMatrixToTexture(wTex, wTexShapeRC[0], wTexShapeRC[1], wData); + + // Figure out the output shape by dilating the input. + const dilatedRC = + conv_util.computeDilatedRC([xShapeRCD[0], xShapeRCD[1]], origStride); + const pad = fieldSize - 1 - origPad; + const resultShapeRCD = conv_util.computeOutputShape3D( + [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, + 1, pad); + + const resultTexRC = conv_util.computeTexShapeFrom3D(resultShapeRCD); + const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + conv_backprop_gpu.convTranspose( + gpgpu, program, xTex, wTex, null, resultTex, resultTexRC); + } + + const y = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexRC[0], resultTexRC[1]); + + const end = performance.now(); + + const avgTime = (end - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteMatrixTexture(wTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; diff --git a/demos/benchmarks/logsumexp_cpu_benchmark.ts b/demos/benchmarks/logsumexp_cpu_benchmark.ts new file mode 100644 index 0000000000..2d398d0b6b --- /dev/null +++ b/demos/benchmarks/logsumexp_cpu_benchmark.ts @@ -0,0 +1,32 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMathCPU} from '../../src/math/math_cpu'; +import {Array2D, NDArray} from '../../src/math/ndarray'; + +import {BenchmarkTest} from './benchmark'; + +const OPS_PER_RUN = 10; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const math = new NDArrayMathCPU(); + const a = NDArray.randUniform([size, size], -1, 1); + const start = performance.now(); + for (let i = 0; i < OPS_PER_RUN; i++) { + math.logSumExp(a); + } + const end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; diff --git a/demos/benchmarks/logsumexp_gpu_benchmark.ts b/demos/benchmarks/logsumexp_gpu_benchmark.ts new file mode 100644 index 0000000000..03f270359b --- /dev/null +++ b/demos/benchmarks/logsumexp_gpu_benchmark.ts @@ -0,0 +1,51 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as logsumexp_gpu from '../../src/math/webgl/logsumexp_gpu'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 100; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const gpgpu = new GPGPUContext(); + + const program = + gpgpu.createProgram(logsumexp_gpu.getFragmentShaderSource(size, size)); + + const aTexture = gpgpu.createMatrixTexture(size, size); + const resultTexture = gpgpu.createMatrixTexture(size, size); + + const a = test_util.randomArrayInRange(size * size, -1, 1); + gpgpu.uploadMatrixToTexture(aTexture, size, size, a); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + logsumexp_gpu.logSumExp( + gpgpu, program, aTexture, size, size, resultTexture); + } + + gpgpu.downloadMatrixFromTexture(resultTexture, size, size); + const avgTime = (performance.now() - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; diff --git a/demos/benchmarks/math-benchmark-run-groups.ts b/demos/benchmarks/math-benchmark-run-groups.ts new file mode 100644 index 0000000000..f616e055bd --- /dev/null +++ b/demos/benchmarks/math-benchmark-run-groups.ts @@ -0,0 +1,79 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {BenchmarkRun, BenchmarkRunGroup} from './benchmark'; +import * as conv_gpu_benchmark from './conv_gpu_benchmark'; +import * as conv_transpose_gpu_benchmark from './conv_transpose_gpu_benchmark'; +import * as logsumexp_cpu_benchmark from './logsumexp_cpu_benchmark'; +import * as logsumexp_gpu_benchmark from './logsumexp_gpu_benchmark'; +import * as max_pool_backprop_gpu_benchmark from './max_pool_backprop_gpu_benchmark'; +import * as max_pool_gpu_benchmark from './max_pool_gpu_benchmark'; +import * as mulmat_cpu_benchmark from './mulmat_cpu_benchmark'; +import * as mulmat_gpu_benchmark from './mulmat_gpu_benchmark'; +import * as tex_util_benchmark from './tex_util_benchmark'; + +export const BENCHMARK_RUN_GROUPS: BenchmarkRunGroup[] = [ + { + name: + 'Matrix Multiplication (CPU vs GPU): matmul([size, size], [size, size])', + min: 0, + max: 1024, + stepSize: 64, + stepToSizeTransformation: (step: number) => Math.max(1, step), + benchmarkRuns: [ + new BenchmarkRun('mulmat_gpu', mulmat_gpu_benchmark.BENCHMARK_TEST), + new BenchmarkRun('mulmat_cpu', mulmat_cpu_benchmark.BENCHMARK_TEST) + ], + }, + { + name: 'Convolution (GPU): conv over image [size, size, 1]', + min: 0, + max: 1024, + stepSize: 64, + stepToSizeTransformation: (step: number) => Math.max(1, step), + benchmarkRuns: [new BenchmarkRun( + 'd1=1, d2=1, f=11, s=1', conv_gpu_benchmark.BENCHMARK_TEST)], + }, + { + name: 'Convolution Transposed (GPU): deconv over image [size, size, 1]', + min: 0, + max: 1024, + stepSize: 64, + stepToSizeTransformation: (step: number) => Math.max(1, step), + benchmarkRuns: [new BenchmarkRun( + 'd1=1, d2=1, f=11, s=1', conv_transpose_gpu_benchmark.BENCHMARK_TEST)], + }, + { + name: 'Max pool (GPU)', + min: 0, + max: 1024, + stepSize: 64, + stepToSizeTransformation: (step: number) => Math.max(1, step), + benchmarkRuns: [new BenchmarkRun( + 'd1=1, d2=1, f=11, s=1', + max_pool_gpu_benchmark.MAX_POOL_BENCHMARK_TEST)], + }, + { + name: 'LogSumExp (CPU vs GPU): input [size, size]', + min: 0, + max: 1024, + stepSize: 64, + stepToSizeTransformation: (step: number) => Math.max(1, step), + benchmarkRuns: [ + new BenchmarkRun('logsumexp_gpu', logsumexp_gpu_benchmark.BENCHMARK_TEST), + new BenchmarkRun('logsumexp_cpu', logsumexp_cpu_benchmark.BENCHMARK_TEST) + ], + } +]; diff --git a/demos/benchmarks/math-benchmark.html b/demos/benchmarks/math-benchmark.html new file mode 100644 index 0000000000..500bff9514 --- /dev/null +++ b/demos/benchmarks/math-benchmark.html @@ -0,0 +1,95 @@ + + + + + + + + + diff --git a/demos/benchmarks/math-benchmark.ts b/demos/benchmarks/math-benchmark.ts new file mode 100644 index 0000000000..6b4bd2533f --- /dev/null +++ b/demos/benchmarks/math-benchmark.ts @@ -0,0 +1,225 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import '../demo-header'; +import '../demo-footer'; + +// tslint:disable-next-line:no-unused-variable +import {PolymerElement, PolymerHTMLElement} from '../polymer-spec'; +import {BenchmarkRunGroup} from './benchmark'; + +import {BENCHMARK_RUN_GROUPS} from './math-benchmark-run-groups'; + +// tslint:disable-next-line:variable-name +export let MathBenchmarkPolymer = PolymerElement( + {is: 'math-benchmark', properties: {benchmarkRunGroupNames: Array}}); + +export class MathBenchmark extends MathBenchmarkPolymer { + // Polymer properties. + private benchmarkRunGroupNames: string[]; + private stopMessages: boolean[]; + + ready() { + // Set up the benchmarks UI. + const benchmarkRunGroupNames: string[] = []; + this.stopMessages = []; + for (let i = 0; i < BENCHMARK_RUN_GROUPS.length; i++) { + benchmarkRunGroupNames.push(BENCHMARK_RUN_GROUPS[i].name); + this.stopMessages.push(false); + } + this.benchmarkRunGroupNames = benchmarkRunGroupNames; + + // In a setTimeout to let the UI update before we add event listeners. + setTimeout(() => { + const runButtons = this.querySelectorAll('.run-test'); + const stopButtons = this.querySelectorAll('.run-stop'); + for (let i = 0; i < runButtons.length; i++) { + runButtons[i].addEventListener('click', () => { + this.runBenchmarkGroup(i); + }); + stopButtons[i].addEventListener('click', () => { + this.stopMessages[i] = true; + }); + } + }, 0); + } + + private runBenchmarkGroup(benchmarkRunGroupIndex: number) { + const benchmarkRunGroup = BENCHMARK_RUN_GROUPS[benchmarkRunGroupIndex]; + + const canvas = this.querySelectorAll('.run-plot')[benchmarkRunGroupIndex] as + HTMLCanvasElement; + const context = canvas.getContext('2d') as CanvasRenderingContext2D; + + const datasets: ChartDataSets[] = []; + for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) { + const hue = Math.floor(360 * i / benchmarkRunGroup.benchmarkRuns.length); + datasets.push({ + data: benchmarkRunGroup.benchmarkRuns[i].chartData, + fill: false, + label: benchmarkRunGroup.benchmarkRuns[i].name, + borderColor: 'hsl(' + hue + ', 100%, 40%)', + backgroundColor: 'hsl(' + hue + ', 100%, 70%)', + pointRadius: 0, + pointHitRadius: 5, + borderWidth: 1, + lineTension: 0 + }); + } + + const chart = new Chart(context, { + type: 'line', + data: {datasets}, + options: { + animation: {duration: 0}, + responsive: false, + scales: { + xAxes: [{ + type: 'linear', + position: 'bottom', + ticks: { + min: benchmarkRunGroup.min, + max: benchmarkRunGroup.max, + stepSize: benchmarkRunGroup.stepSize, + callback: (label: string) => { + return benchmarkRunGroup.stepToSizeTransformation != null ? + benchmarkRunGroup.stepToSizeTransformation(+label) : + +label; + } + // tslint:disable-next-line:no-any + } as any // Note: the typings for this are incorrect, cast as any. + }], + yAxes: [{ + ticks: { + callback: (label, index, labels) => { + return label + 'ms'; + } + }, + }] + }, + tooltips: {mode: 'label'}, + title: {text: benchmarkRunGroup.name} + } + }); + canvas.style.display = 'none'; + + const runMessage = + this.querySelectorAll('.run-message')[benchmarkRunGroupIndex] as + HTMLElement; + runMessage.style.display = 'block'; + + const runNumbersTable = + this.querySelectorAll('.run-numbers-table')[benchmarkRunGroupIndex] as + HTMLElement; + runNumbersTable.innerHTML = ''; + runNumbersTable.style.display = 'none'; + + // Set up the header for the table. + const headers = ['size']; + for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) { + headers.push(benchmarkRunGroup.benchmarkRuns[i].name); + } + runNumbersTable.appendChild(this.buildRunNumbersRow(headers)); + + this.runBenchmarkSteps( + chart, benchmarkRunGroup, benchmarkRunGroupIndex, + benchmarkRunGroup.min); + } + + private buildRunNumbersRow(values: string[]) { + const runNumberRowElement = document.createElement('div'); + runNumberRowElement.className = 'run-numbers-row math-benchmark'; + + for (let i = 0; i < values.length; i++) { + const runNumberCellElement = document.createElement('div'); + runNumberCellElement.className = 'run-numbers-cell math-benchmark'; + runNumberCellElement.innerText = values[i]; + runNumberRowElement.appendChild(runNumberCellElement); + } + return runNumberRowElement; + } + + private runBenchmarkSteps( + chart: Chart, benchmarkRunGroup: BenchmarkRunGroup, + benchmarkRunGroupIndex: number, step: number) { + const runNumbersTable = + this.querySelectorAll('.run-numbers-table')[benchmarkRunGroupIndex] as + HTMLElement; + if (step > benchmarkRunGroup.max || + this.stopMessages[benchmarkRunGroupIndex]) { + this.stopMessages[benchmarkRunGroupIndex] = false; + + runNumbersTable.style.display = ''; + + const canvas = + this.querySelectorAll('.run-plot')[benchmarkRunGroupIndex] as + HTMLCanvasElement; + canvas.style.display = 'block'; + chart.update(); + + const runMessage = + this.querySelectorAll('.run-message')[benchmarkRunGroupIndex] as + HTMLElement; + runMessage.style.display = 'none'; + + return; + } + + const runNumberRowElement = document.createElement('div'); + runNumberRowElement.className = 'run-numbers-row math-benchmark'; + + const rowValues: string[] = ['' + step]; + for (let i = 0; i < benchmarkRunGroup.benchmarkRuns.length; i++) { + const benchmarkRun = benchmarkRunGroup.benchmarkRuns[i]; + const benchmarkTest = benchmarkRun.benchmarkTest; + + const size = benchmarkRunGroup.stepToSizeTransformation != null ? + benchmarkRunGroup.stepToSizeTransformation(step) : + step; + + let resultString: string; + let logString: string; + let time = 0; + let success = true; + + try { + time = benchmarkTest(size); + resultString = time.toFixed(3) + 'ms'; + logString = resultString; + } catch (e) { + success = false; + resultString = 'Error'; + logString = e.message; + } + + if (time >= 0) { + if (success) { + benchmarkRun.chartData.push({x: step, y: time}); + } + rowValues.push(resultString); + } + console.log(benchmarkRun.name + '[' + step + ']: ' + logString); + } + runNumbersTable.appendChild(this.buildRunNumbersRow(rowValues)); + + step += benchmarkRunGroup.stepSize; + // Allow the UI to update. + setTimeout( + () => this.runBenchmarkSteps( + chart, benchmarkRunGroup, benchmarkRunGroupIndex, step), + 100); + } +} +document.registerElement(MathBenchmark.prototype.is, MathBenchmark); diff --git a/demos/benchmarks/max_pool_backprop_gpu_benchmark.ts b/demos/benchmarks/max_pool_backprop_gpu_benchmark.ts new file mode 100644 index 0000000000..7dab36b3d0 --- /dev/null +++ b/demos/benchmarks/max_pool_backprop_gpu_benchmark.ts @@ -0,0 +1,82 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../../src/math/conv_util'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as max_pool_backprop_gpu from '../../src/math/webgl/max_pool_backprop_gpu'; +import * as test_util from '../../src/test_util'; +import * as util from '../../src/util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 100; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const dyShapeRCD: [number, number, number] = [size, size, 1]; + const outputDepth = 1; + const fieldSize = 11; + const stride = 1; + const zeroPad = conv_util.computeDefaultPad(dyShapeRCD, fieldSize, stride); + const outputShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + dyShapeRCD, fieldSize, outputDepth, stride, zeroPad); + + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram( + max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop( + dyShapeRCD, fieldSize, stride, zeroPad)); + + const dyTexture = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + const maxPositionsTexture = + gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + const outputTexture = + gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + + const dyData = + test_util.randomArrayInRange(dyTexShapeRC[0] * dyTexShapeRC[1], -1, 1); + const maxPositionsData = new Float32Array(util.sizeFromShape(dyShapeRCD)); + for (let i = 0; i < maxPositionsData.length; i++) { + maxPositionsData[i] = Math.floor(Math.random() * fieldSize * fieldSize); + } + + gpgpu.uploadMatrixToTexture( + dyTexture, dyTexShapeRC[0], dyTexShapeRC[1], dyData); + gpgpu.uploadMatrixToTexture( + maxPositionsTexture, dyTexShapeRC[0], dyTexShapeRC[1], maxPositionsData); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + max_pool_backprop_gpu.maxPoolBackprop( + gpgpu, program, dyTexture, maxPositionsTexture, outputTexture, + outputTexShapeRC); + } + + gpgpu.downloadMatrixFromTexture( + outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + const end = performance.now(); + + const avgTime = (end - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(dyTexture); + gpgpu.deleteMatrixTexture(maxPositionsTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; \ No newline at end of file diff --git a/demos/benchmarks/max_pool_gpu_benchmark.ts b/demos/benchmarks/max_pool_gpu_benchmark.ts new file mode 100644 index 0000000000..bb1e6a6e24 --- /dev/null +++ b/demos/benchmarks/max_pool_gpu_benchmark.ts @@ -0,0 +1,121 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../../src/math/conv_util'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as max_pool_gpu from '../../src/math/webgl/max_pool_gpu'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 40; + +export const MAX_POOL_BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const inputShapeRCD: [number, number, number] = [size, size, 1]; + const outputDepth = 1; + const fieldSize = 11; + const stride = 1; + const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride); + const outputShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + inputShapeRCD, fieldSize, outputDepth, stride, zeroPad); + + const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + + const gpgpu = new GPGPUContext(); + const program = + gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolSource( + inputShapeRCD, fieldSize, stride, zeroPad)); + + const inputTexture = + gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]); + const outputTexture = + gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + + const inputData = test_util.randomArrayInRange( + inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1); + + gpgpu.uploadMatrixToTexture( + inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + max_pool_gpu.maxPoolCommon( + gpgpu, program, inputTexture, outputTexture, outputTexShapeRC); + } + + gpgpu.downloadMatrixFromTexture( + outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + const end = performance.now(); + + const avgTime = (end - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(inputTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; + +export const MAX_POOL_POSNS_BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const inputShapeRCD: [number, number, number] = [size, size, 1]; + const outputDepth = 1; + const fieldSize = 11; + const stride = 1; + const zeroPad = conv_util.computeDefaultPad(inputShapeRCD, fieldSize, stride); + const outputShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + inputShapeRCD, fieldSize, outputDepth, stride, zeroPad); + + const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + const outputTexShapeRC = conv_util.computeTexShapeFrom3D(outputShapeRCD); + + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = + gpgpu.createProgram(max_pool_gpu.getFragmentShaderMaxPoolPositionsSource( + inputShapeRCD, fieldSize, stride, zeroPad)); + + const inputTexture = + gpgpu.createMatrixTexture(inputTexShapeRC[0], inputTexShapeRC[1]); + const outputTexture = + gpgpu.createMatrixTexture(outputTexShapeRC[0], outputTexShapeRC[1]); + + const inputData = test_util.randomArrayInRange( + inputTexShapeRC[0] * inputTexShapeRC[1], -1, 1); + + gpgpu.uploadMatrixToTexture( + inputTexture, inputTexShapeRC[0], inputTexShapeRC[1], inputData); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + max_pool_gpu.maxPoolCommon( + gpgpu, program, inputTexture, outputTexture, outputTexShapeRC); + } + + gpgpu.downloadMatrixFromTexture( + outputTexture, outputTexShapeRC[0], outputTexShapeRC[1]); + const end = performance.now(); + + const avgTime = (end - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(inputTexture); + gpgpu.deleteMatrixTexture(outputTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; \ No newline at end of file diff --git a/demos/benchmarks/mulmat_cpu_benchmark.ts b/demos/benchmarks/mulmat_cpu_benchmark.ts new file mode 100644 index 0000000000..1e6ab8ea90 --- /dev/null +++ b/demos/benchmarks/mulmat_cpu_benchmark.ts @@ -0,0 +1,37 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMathCPU} from '../../src/math/math_cpu'; +import {Array2D, NDArray} from '../../src/math/ndarray'; + +import {BenchmarkTest} from './benchmark'; + +const OPS_PER_SMALL_RUN = 1; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + if (size > 512) { + return -1; + } + const math = new NDArrayMathCPU(); + const a = NDArray.randUniform([size, size], -1, 1); + const b = NDArray.randUniform([size, size], -1, 1); + const runs = (size < 192) ? OPS_PER_SMALL_RUN : 1; + const start = performance.now(); + for (let i = 0; i < runs; i++) { + math.matMul(a, b); + } + const end = performance.now(); + return (end - start) / runs; +}; diff --git a/demos/benchmarks/mulmat_gpu_benchmark.ts b/demos/benchmarks/mulmat_gpu_benchmark.ts new file mode 100644 index 0000000000..3b69e9a0ba --- /dev/null +++ b/demos/benchmarks/mulmat_gpu_benchmark.ts @@ -0,0 +1,98 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MatrixOrientation} from '../../src/math/math'; +import {Array2D} from '../../src/math/ndarray'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as mulmat_gpu from '../../src/math/webgl/mulmat_gpu'; +import * as mulmat_packed_gpu from '../../src/math/webgl/mulmat_packed_gpu'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OP_RUNS = 40; + +export const BENCHMARK_TEST: BenchmarkTest = (size: number) => { + const gpgpu = new GPGPUContext(); + const aTexture = gpgpu.createMatrixTexture(size, size); + const bTexture = gpgpu.createMatrixTexture(size, size); + const resultTexture = gpgpu.createMatrixTexture(size, size); + + const aArr = new Array2D( + [size, size], {texture: aTexture, textureShapeRC: [size, size]}); + const bArr = new Array2D( + [size, size], {texture: bTexture, textureShapeRC: [size, size]}); + const resArr = new Array2D( + [size, size], {texture: resultTexture, textureShapeRC: [size, size]}); + const program = gpgpu.createProgram(mulmat_gpu.getFragmentShader( + aArr, bArr, resArr, MatrixOrientation.REGULAR, + MatrixOrientation.REGULAR)); + + const a = test_util.randomArrayInRange(size * size, -1, 1); + const b = test_util.randomArrayInRange(size * size, -1, 1); + gpgpu.uploadMatrixToTexture(aTexture, size, size, a); + gpgpu.uploadMatrixToTexture(bTexture, size, size, b); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + mulmat_gpu.multiplyMatrix( + gpgpu, program, aTexture, bTexture, resultTexture, [size, size]); + } + + const actual = gpgpu.downloadMatrixFromTexture(resultTexture, size, size); + const avgTime = (performance.now() - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; + +export const BENCHMARK_TEST_PACKED: BenchmarkTest = (size: number) => { + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = + gpgpu.createProgram(mulmat_packed_gpu.getFragmentShaderSource( + size, MatrixOrientation.REGULAR, MatrixOrientation.REGULAR)); + + const aTexture = gpgpu.createPackedMatrixTexture(size, size); + const bTexture = gpgpu.createPackedMatrixTexture(size, size); + const resultTexture = gpgpu.createPackedMatrixTexture(size, size); + + const a = test_util.randomArrayInRange(size * size, -1, 1); + const b = test_util.randomArrayInRange(size * size, -1, 1); + gpgpu.uploadMatrixToPackedTexture(aTexture, size, size, a); + gpgpu.uploadMatrixToPackedTexture(bTexture, size, size, b); + + const start = performance.now(); + for (let i = 0; i < OP_RUNS; i++) { + mulmat_packed_gpu.multiplyMatrixPacked( + gpgpu, program, aTexture, bTexture, resultTexture, [size, size]); + } + + const actual = + gpgpu.downloadMatrixFromPackedTexture(resultTexture, size, size); + const avgTime = (performance.now() - start) / OP_RUNS; + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return avgTime; +}; diff --git a/demos/benchmarks/tex_util_benchmark.ts b/demos/benchmarks/tex_util_benchmark.ts new file mode 100644 index 0000000000..4b4e684e86 --- /dev/null +++ b/demos/benchmarks/tex_util_benchmark.ts @@ -0,0 +1,80 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as gpgpu_util from '../../src/math/webgl/gpgpu_util'; +import * as tex_util from '../../src/math/webgl/tex_util'; +import * as webgl_util from '../../src/math/webgl/webgl_util'; +import * as test_util from '../../src/test_util'; + +import {BenchmarkTest} from './benchmark'; + +const OPS_PER_RUN = 100; + +export const BENCHMARK_ENCODE_UNPACKED: BenchmarkTest = (size: number) => { + const matrix = test_util.randomArrayInRange(size * size, -1, 1); + const channelsPerTexture = webgl_util.getChannelsPerTexture(); + const unpackedArray = + new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize( + matrix.length, channelsPerTexture)); + const start = performance.now(); + for (let i = 0; i < OPS_PER_RUN; ++i) { + tex_util.encodeMatrixToUnpackedArray( + matrix, unpackedArray, channelsPerTexture); + } + const end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; + +export const BENCHMARK_ENCODE_PACKED: BenchmarkTest = (size: number) => { + const matrix = test_util.randomArrayInRange(size * size, -1, 1); + const packedRGBA = new Float32Array( + tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size)); + const start = performance.now(); + for (let i = 0; i < OPS_PER_RUN; ++i) { + tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA); + } + const end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; + +export const BENCHMARK_DECODE_UNPACKED: BenchmarkTest = (size: number) => { + const matrix = test_util.randomArrayInRange(size * size, -1, 1); + const channelsPerTexture = webgl_util.getChannelsPerTexture(); + const unpackedArray = + new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize( + matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray( + matrix, unpackedArray, channelsPerTexture); + const start = performance.now(); + for (let i = 0; i < OPS_PER_RUN; ++i) { + tex_util.decodeMatrixFromUnpackedArray( + unpackedArray, matrix, channelsPerTexture); + } + const end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; + +export const BENCHMARK_DECODE_PACKED: BenchmarkTest = (size: number) => { + const matrix = test_util.randomArrayInRange(size * size, -1, 1); + const packedRGBA = new Float32Array( + tex_util.getPackedRGBAArraySizeFromMatrixShape(size, size)); + tex_util.encodeMatrixToPackedRGBA(matrix, size, size, packedRGBA); + const start = performance.now(); + for (let i = 0; i < OPS_PER_RUN; ++i) { + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, size, size, matrix); + } + const end = performance.now(); + return (end - start) / OPS_PER_RUN; +}; diff --git a/demos/chartjs.d.ts b/demos/chartjs.d.ts new file mode 100644 index 0000000000..da223558c2 --- /dev/null +++ b/demos/chartjs.d.ts @@ -0,0 +1,448 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +// Type definitions for Chart.js +// Project: https://github.com/nnnick/Chart.js +// Definitions by: Alberto Nuti +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +/* This project is licensed under the MIT license. +Copyrights are respective of each contributor listed at the beginning of each +definition file. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ + +declare enum ChartType { line, bar, radar, doughnut, polarArea, bubble } +declare enum TimeUnit { + millisecond, + second, + minute, + hour, + day, + week, + month, + quarter, + year +} +interface ChartLegendItem { + text?: string; + fillStyle?: string; + hidden?: boolean; + lineCap?: string; + lineDash?: number[]; + lineDashOffset?: number; + lineJoin?: string; + lineWidth?: number; + strokeStyle?: string; +} +interface ChartTooltipItem { + xLabel?: string; + yLabel?: string; + datasetIndex?: number; + index?: number; +} +interface ChartTooltipCallback { + beforeTitle?: (item?: ChartTooltipItem[], data?: any) => void; + title?: (item?: ChartTooltipItem[], data?: any) => void; + afterTitle?: (item?: ChartTooltipItem[], data?: any) => void; + beforeBody?: (item?: ChartTooltipItem[], data?: any) => void; + beforeLabel?: (tooltipItem?: ChartTooltipItem, data?: any) => void; + label?: (tooltipItem?: ChartTooltipItem, data?: any) => void; + afterLabel?: (tooltipItem?: ChartTooltipItem, data?: any) => void; + afterBody?: (item?: ChartTooltipItem[], data?: any) => void; + beforeFooter?: (item?: ChartTooltipItem[], data?: any) => void; + footer?: (item?: ChartTooltipItem[], data?: any) => void; + afterfooter?: (item?: ChartTooltipItem[], data?: any) => void; +} +interface ChartAnimationParameter { + chartInstance?: any; + animationObject?: any; +} +interface ChartPoint { + x?: number; + y?: number; +} + +interface ChartConfiguration { + type?: string; + data?: ChartData; + options?: ChartOptions; +} + +interface ChartData {} + +interface LinearChartData extends ChartData { + labels?: string[]; + datasets?: ChartDataSets[]; +} + +interface ChartOptions { + responsive?: boolean; + responsiveAnimationDuration?: number; + maintainAspectRatio?: boolean; + events?: string[]; + onClick?: (any?: any) => any; + title?: ChartTitleOptions; + legend?: ChartLegendOptions; + tooltips?: ChartTooltipOptions; + hover?: ChartHoverOptions; + animation?: ChartAnimationOptions; + elements?: ChartElementsOptions; + scales?: ChartScales; +} + +interface ChartFontOptions { + defaultFontColor?: ChartColor; + defaultFontFamily?: string; + defaultFontSize?: number; + defaultFontStyle?: string; +} + +interface ChartTitleOptions { + display?: boolean; + position?: string; + fullWdith?: boolean; + fontSize?: number; + fontFamily?: string; + fontColor?: ChartColor; + fontStyle?: string; + padding?: number; + text?: string; +} + +interface ChartLegendOptions { + display?: boolean; + position?: string; + fullWidth?: boolean; + onClick?: (event: any, legendItem: any) => void; + labels?: ChartLegendLabelOptions; +} + +interface ChartLegendLabelOptions { + boxWidth?: number; + fontSize?: number; + fontStyle?: number; + fontColor?: ChartColor; + fontFamily?: string; + padding?: number; + generateLabels?: (chart: any) => any; +} + +interface ChartTooltipOptions { + enabled?: boolean; + custom?: (a: any) => void; + mode?: string; + backgroundColor?: ChartColor; + titleFontFamily?: string; + titleFontSize?: number; + titleFontStyle?: string; + titleFontColor?: ChartColor; + titleSpacing?: number; + titleMarginBottom?: number; + bodyFontFamily?: string; + bodyFontSize?: number; + bodyFontStyle?: string; + bodyFontColor?: ChartColor; + bodySpacing?: number; + footerFontFamily?: string; + footerFontSize?: number; + footerFontStyle?: string; + footerFontColor?: ChartColor; + footerSpacing?: number; + footerMarginTop?: number; + xPadding?: number; + yPadding?: number; + caretSize?: number; + cornerRadius?: number; + multiKeyBackground?: string; + callbacks?: ChartTooltipCallback; +} + +interface ChartHoverOptions { + mode?: string; + animationDuration?: number; + onHover?: (active: any) => void; +} + +interface ChartAnimationObject { + currentStep?: number; + numSteps?: number; + easing?: string; + render?: (arg: any) => void; + onAnimationProgress?: (arg: any) => void; + onAnimationComplete?: (arg: any) => void; +} + +interface ChartAnimationOptions { + duration?: number; + easing?: string; + onProgress?: (chart: any) => void; + onComplete?: (chart: any) => void; +} + +interface ChartElementsOptions { + point?: ChartPointOptions; + line?: ChartLineOptions; + arg?: ChartArcOtpions; + rectangle?: ChartRectangleOptions; +} + +interface ChartArcOtpions { + backgroundColor?: ChartColor; + borderColor?: ChartColor; + borderWidth?: number; +} + +interface ChartLineOptions { + tension?: number; + backgroundColor?: ChartColor; + borderWidth?: number; + borderColor?: ChartColor; + borderCapStyle?: string; + borderDash?: any[]; + borderDashOffset?: number; + borderJoinStyle?: string; +} + +interface ChartPointOptions { + radius?: number; + pointStyle?: string; + backgroundColor?: ChartColor; + borderWidth?: number; + borderColor?: ChartColor; + hitRadius?: number; + hoverRadius?: number; + hoverBorderWidth?: number; +} + +interface ChartRectangleOptions { + backgroundColor?: ChartColor; + borderWidth?: number; + borderColor?: ChartColor; + borderSkipped?: string; +} +interface GridLineOptions { + display?: boolean; + color?: ChartColor; + lineWidth?: number; + drawBorder?: boolean; + drawOnChartArea?: boolean; + drawticks?: boolean; + tickMarkLength?: number; + zeroLineWidth?: number; + zeroLineColor?: ChartColor; + offsetGridLines?: boolean; +} + +interface ScaleTitleOptions { + display?: boolean; + labelString?: string; + fontColor?: ChartColor; + fontFamily?: string; + fontSize?: number; + fontStyle?: string; +} + +interface TickOptions { + autoSkip?: boolean; + callback?: (value: any, index: any, values: any) => string; + display?: boolean; + fontColor?: ChartColor; + fontFamily?: string; + fontSize?: number; + fontStyle?: string; + labelOffset?: number; + maxRotation?: number; + minRotation?: number; + mirror?: boolean; + padding?: number; + reverse?: boolean; + min?: any; + max?: any; +} +interface AngleLineOptions { + display?: boolean; + color?: ChartColor; + lineWidth?: number; +} + +interface PointLabelOptions { + callback?: (arg: any) => any; + fontColor?: ChartColor; + fontFamily?: string; + fontSize?: number; + fontStyle?: string; +} + +interface TickOptions { + backdropColor?: ChartColor; + backdropPaddingX?: number; + backdropPaddingY?: number; + maxTicksLimit?: number; + showLabelBackdrop?: boolean; +} +interface LinearTickOptions extends TickOptions { + beginAtZero?: boolean; + min?: number; + max?: number; + maxTicksLimit?: number; + stepSize?: number; + suggestedMin?: number; + suggestedMax?: number; +} + +interface LogarithmicTickOptions extends TickOptions { + min?: number; + max?: number; +} + +type ChartColor = string|CanvasGradient|CanvasPattern; + +interface ChartDataSets { + backgroundColor?: ChartColor; + borderWidth?: number; + borderColor?: ChartColor; + borderCapStyle?: string; + borderDash?: number[]; + borderDashOffset?: number; + borderJoinStyle?: string; + data?: number[]|ChartPoint[]; + fill?: boolean; + label?: string; + lineTension?: number; + pointBorderColor?: ChartColor|ChartColor[]; + pointBackgroundColor?: ChartColor|ChartColor[]; + pointBorderWidth?: number|number[]; + pointRadius?: number|number[]; + pointHoverRadius?: number|number[]; + pointHitRadius?: number|number[]; + pointHoverBackgroundColor?: ChartColor|ChartColor[]; + pointHoverBorderColor?: ChartColor|ChartColor[]; + pointHoverBorderWidth?: number|number[]; + pointStyle?: string|string[]|HTMLImageElement|HTMLImageElement[]; + xAxisID?: string; + yAxisID?: string; +} + +interface ChartScales { + type?: string; + display?: boolean; + position?: string; + beforeUpdate?: (scale?: any) => void; + beforeSetDimension?: (scale?: any) => void; + beforeDataLimits?: (scale?: any) => void; + beforeBuildTicks?: (scale?: any) => void; + beforeTickToLabelConversion?: (scale?: any) => void; + beforeCalculateTickRotation?: (scale?: any) => void; + beforeFit?: (scale?: any) => void; + afterUpdate?: (scale?: any) => void; + afterSetDimension?: (scale?: any) => void; + afterDataLimits?: (scale?: any) => void; + afterBuildTicks?: (scale?: any) => void; + afterTickToLabelConversion?: (scale?: any) => void; + afterCalculateTickRotation?: (scale?: any) => void; + afterFit?: (scale?: any) => void; + gridLines?: GridLineOptions; + scaleLabel?: ScaleTitleOptions; + ticks?: TickOptions; + xAxes?: ChartXAxe[]; + yAxes?: ChartYAxe[]; +} + +interface ChartXAxe { + type?: string; + display?: boolean; + id?: string; + stacked?: boolean; + categoryPercentage?: number; + barPercentage?: number; + barThickness?: number; + gridLines?: GridLineOptions; + position?: string; + ticks?: TickOptions; + time?: TimeScale; + scaleLabel?: ScaleTitleOptions; +} + +interface ChartYAxe { + type?: string; + display?: boolean; + id?: string; + stacked?: boolean; + position?: string; + ticks?: TickOptions; + scaleLabel?: ScaleTitleOptions; +} + +interface LinearScale extends ChartScales { + ticks?: LinearTickOptions; +} + +interface LogarithmicScale extends ChartScales { + ticks?: LogarithmicTickOptions; +} + +interface TimeScale extends ChartScales { + format?: string; + displayFormats?: string; + isoWeekday?: boolean; + max?: string; + min?: string; + parser?: string|((arg: any) => any); + round?: string; + tooltipFormat?: string; + unit?: string|TimeUnit; + unitStepSize?: number; +} + +interface RadialLinearScale { + lineArc?: boolean; + angleLines?: AngleLineOptions; + pointLabels?: PointLabelOptions; + ticks?: TickOptions; +} + +declare class Chart { + constructor(context: CanvasRenderingContext2D, options: ChartConfiguration); + config: ChartConfiguration; + destroy: () => {}; + update: (duration?: any, lazy?: any) => {}; + render: (duration?: any, lazy?: any) => {}; + stop: () => {}; + resize: () => {}; + clear: () => {}; + toBase64: () => string; + generateLegend: () => {}; + getElementAtEvent: (e: any) => {}; + getElementsAtEvent: (e: any) => {}[]; + getDatasetAtEvent: (e: any) => {}[]; + + defaults: {global: ChartOptions;} +} diff --git a/demos/deeplearnjs.ts b/demos/deeplearnjs.ts new file mode 100644 index 0000000000..2162ae1663 --- /dev/null +++ b/demos/deeplearnjs.ts @@ -0,0 +1,18 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +// This file is just an alias that points to the current deeplearnjs version +// at this branch, so demos can import the library as '../deeplearnjs'. +export * from '../src/index'; diff --git a/demos/demo-footer.html b/demos/demo-footer.html new file mode 100644 index 0000000000..5a58016b69 --- /dev/null +++ b/demos/demo-footer.html @@ -0,0 +1,56 @@ + + + + + + diff --git a/demos/demo-footer.ts b/demos/demo-footer.ts new file mode 100644 index 0000000000..b619e6d665 --- /dev/null +++ b/demos/demo-footer.ts @@ -0,0 +1,15 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ +Polymer({is: 'demo-footer'}); diff --git a/demos/demo-header.html b/demos/demo-header.html new file mode 100644 index 0000000000..eb8464822c --- /dev/null +++ b/demos/demo-header.html @@ -0,0 +1,48 @@ + + + + + + + + + + diff --git a/demos/demo-header.ts b/demos/demo-header.ts new file mode 100644 index 0000000000..4c0ea28db3 --- /dev/null +++ b/demos/demo-header.ts @@ -0,0 +1,15 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ +Polymer({is: 'demo-header'}); diff --git a/demos/font-embedding/bundle.js b/demos/font-embedding/bundle.js new file mode 100644 index 0000000000..5d0fd6a2a4 --- /dev/null +++ b/demos/font-embedding/bundle.js @@ -0,0 +1,8217 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 56443) { + return; + } + var embedding = []; + var embeddingNDArray = this.variables['input_from_feature_columns/font_embedding/weights']; + for (var i = 0; i < embeddingNDArray.shape[1]; i++) { + var num = embeddingNDArray.get(+fontId, i); + embedding.push({ init: num, val: num }); + } + this.set('embedding', embedding); + }; + FontEmbedding.prototype.sliderChange = function (e) { + var element = e.target; + var index = parseInt(element.getAttribute('data-index'), 10); + this.embedding[index].val = element.immediateValue; + this.infer(this.fontId, this.char); + }; + FontEmbedding.prototype.buildModel = function () { + this.vis = this.$.vis; + this.vis.setShape([64, 64]); + this.vis.setSize(128, 128); + this.newFontId(this.fontId); + var fc1wName = 'Stack/fully_connected_1/weights'; + var fc1bName = 'Stack/fully_connected_1/biases'; + var fc2wName = 'Stack/fully_connected_2/weights'; + var fc2bName = 'Stack/fully_connected_2/biases'; + var fc3wName = 'Stack/fully_connected_3/weights'; + var fc3bName = 'Stack/fully_connected_3/biases'; + var fc4wName = 'Stack/fully_connected_4/weights'; + var fc4bName = 'Stack/fully_connected_4/biases'; + var fc5wName = 'fully_connected/weights'; + var fc5bName = 'fully_connected/biases'; + this.graph = new learnjs_1.Graph(); + var g = this.graph; + this.inputTensor = g.placeholder('input', [102]); + var relu1 = g.layers.dense('fc1', this.inputTensor, this.variables[fc1bName].shape[1], function (x) { return g.relu(x); }, true, new learnjs_1.NDArrayInitializer(this.variables[fc1wName]), new learnjs_1.NDArrayInitializer(this.variables[fc1bName])); + var relu2 = g.layers.dense('fc2', relu1, this.variables[fc2bName].shape[1], function (x) { return g.relu(x); }, true, new learnjs_1.NDArrayInitializer(this.variables[fc2wName]), new learnjs_1.NDArrayInitializer(this.variables[fc2bName])); + var relu3 = g.layers.dense('fc3', relu2, this.variables[fc3bName].shape[1], function (x) { return g.relu(x); }, true, new learnjs_1.NDArrayInitializer(this.variables[fc3wName]), new learnjs_1.NDArrayInitializer(this.variables[fc3bName])); + var relu4 = g.layers.dense('fc4', relu3, this.variables[fc4bName].shape[1], function (x) { return g.relu(x); }, true, new learnjs_1.NDArrayInitializer(this.variables[fc4wName]), new learnjs_1.NDArrayInitializer(this.variables[fc4bName])); + this.outputTensor = g.layers.dense('fc5', relu4, this.variables[fc5bName].shape[1], function (x) { return g.sigmoid(x); }, true, new learnjs_1.NDArrayInitializer(this.variables[fc5wName]), new learnjs_1.NDArrayInitializer(this.variables[fc5bName])); + this.math = new learnjs_1.NDArrayMathGPU(); + this.session = new learnjs_1.Session(g, this.math); + }; + FontEmbedding.prototype.infer = function (fontId, char) { + var _this = this; + if (fontId.length === 0 || +fontId < 0 || +fontId > 56443 || + char.length === 0) { + return; + } + var charId = this.charIdMap[char.charAt(0)]; + if (charId == null) { + return; + } + var onehot = Array.apply(null, Array(this.numberOfValidChars)) + .map(Number.prototype.valueOf, 0); + onehot[charId] = 1; + var embedding = this.embedding.map(function (settings) { return settings.val; }); + this.math.scope(function (keep, track) { + var inputData = track(learnjs_1.Array1D.new(embedding.concat(onehot))); + var infer = _this.session.eval(_this.outputTensor, [{ tensor: _this.inputTensor, data: inputData }]); + var scalar = track(learnjs_1.Scalar.new(255)); + var scaled = _this.math.scalarTimesArray(scalar, infer); + var adjusted = _this.math.scalarMinusArray(scalar, scaled); + _this.vis.saveImageDataFromNDArray(adjusted.as3D(64, 64, 1)); + _this.vis.draw(); + }); + }; + return FontEmbedding; +}(exports.FontEmbeddingPolymer)); +exports.FontEmbedding = FontEmbedding; +document.registerElement(FontEmbedding.prototype.is, FontEmbedding); + +},{"../demo-footer":1,"../demo-header":2,"../learnjs":4,"../ndarray-image-visualizer":5,"../polymer-spec":6}],4:[function(require,module,exports){ +"use strict"; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", { value: true }); +__export(require("../src/index")); + +},{"../src/index":13}],5:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var polymer_spec_1 = require("./polymer-spec"); +exports.NDArrayImageVisualizerPolymer = polymer_spec_1.PolymerElement({ is: 'ndarray-image-visualizer', properties: {} }); +var NDArrayImageVisualizer = (function (_super) { + __extends(NDArrayImageVisualizer, _super); + function NDArrayImageVisualizer() { + return _super !== null && _super.apply(this, arguments) || this; + } + NDArrayImageVisualizer.prototype.ready = function () { + this.canvas = this.querySelector('#canvas'); + this.canvas.width = 0; + this.canvas.height = 0; + this.canvasContext = + this.canvas.getContext('2d'); + this.canvas.style.display = 'none'; + }; + NDArrayImageVisualizer.prototype.setShape = function (shape) { + this.canvas.width = shape[1]; + this.canvas.height = shape[0]; + }; + NDArrayImageVisualizer.prototype.setSize = function (width, height) { + this.canvas.style.width = width + 'px'; + this.canvas.style.height = height + 'px'; + }; + NDArrayImageVisualizer.prototype.saveImageDataFromNDArray = function (ndarray) { + this.imageData = this.canvasContext.createImageData(this.canvas.width, this.canvas.height); + if (ndarray.shape[2] === 1) { + this.drawGrayscaleImageData(ndarray); + } + else if (ndarray.shape[2] === 3) { + this.drawRGBImageData(ndarray); + } + }; + NDArrayImageVisualizer.prototype.drawRGBImageData = function (ndarray) { + var pixelOffset = 0; + for (var i = 0; i < ndarray.shape[0]; i++) { + for (var j = 0; j < ndarray.shape[1]; j++) { + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 1); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 2); + this.imageData.data[pixelOffset++] = 255; + } + } + }; + NDArrayImageVisualizer.prototype.drawGrayscaleImageData = function (ndarray) { + var pixelOffset = 0; + for (var i = 0; i < ndarray.shape[0]; i++) { + for (var j = 0; j < ndarray.shape[1]; j++) { + var value = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = 255; + } + } + }; + NDArrayImageVisualizer.prototype.draw = function () { + this.canvas.style.display = ''; + this.canvasContext.putImageData(this.imageData, 0, 0); + }; + return NDArrayImageVisualizer; +}(exports.NDArrayImageVisualizerPolymer)); +exports.NDArrayImageVisualizer = NDArrayImageVisualizer; +document.registerElement(NDArrayImageVisualizer.prototype.is, NDArrayImageVisualizer); + +},{"./polymer-spec":6}],6:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function PolymerElement(spec) { + return Polymer.Class(spec); +} +exports.PolymerElement = PolymerElement; + +},{}],7:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var MANIFEST_FILE = 'manifest.json'; +var CheckpointLoader = (function () { + function CheckpointLoader(urlPath) { + this.urlPath = urlPath; + if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') { + this.urlPath += '/'; + } + } + CheckpointLoader.prototype.loadManifest = function () { + var _this = this; + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', _this.urlPath + MANIFEST_FILE); + xhr.onload = function () { + _this.checkpointManifest = JSON.parse(xhr.responseText); + resolve(); + }; + xhr.onerror = function (error) { + throw new Error(MANIFEST_FILE + " not found at " + _this.urlPath + ". " + error); + }; + xhr.send(); + }); + }; + CheckpointLoader.prototype.getCheckpointManifest = function () { + var _this = this; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + resolve(_this.checkpointManifest); + }); + }); + } + return new Promise(function (resolve, reject) { + resolve(_this.checkpointManifest); + }); + }; + CheckpointLoader.prototype.getAllVariables = function () { + var _this = this; + if (this.variables != null) { + return new Promise(function (resolve, reject) { + resolve(_this.variables); + }); + } + return new Promise(function (resolve, reject) { + _this.getCheckpointManifest().then(function (checkpointDefinition) { + var variableNames = Object.keys(_this.checkpointManifest); + var variablePromises = []; + for (var i = 0; i < variableNames.length; i++) { + variablePromises.push(_this.getVariable(variableNames[i])); + } + Promise.all(variablePromises).then(function (variables) { + _this.variables = {}; + for (var i = 0; i < variables.length; i++) { + _this.variables[variableNames[i]] = variables[i]; + } + resolve(_this.variables); + }); + }); + }); + }; + CheckpointLoader.prototype.getVariable = function (varName) { + var _this = this; + if (!(varName in this.checkpointManifest)) { + throw new Error('Cannot load non-existant variable ' + varName); + } + var variableRequestPromiseMethod = function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.responseType = 'arraybuffer'; + var fname = _this.checkpointManifest[varName].filename; + xhr.open('GET', _this.urlPath + fname); + xhr.onload = function () { + var values = new Float32Array(xhr.response); + var ndarray = ndarray_1.NDArray.make(_this.checkpointManifest[varName].shape, { values: values }); + resolve(ndarray); + }; + xhr.onerror = function (error) { + throw new Error('Could not fetch variable ' + varName + ': ' + error); + }; + xhr.send(); + }; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + new Promise(variableRequestPromiseMethod).then(resolve); + }); + }); + } + return new Promise(variableRequestPromiseMethod); + }; + return CheckpointLoader; +}()); +exports.CheckpointLoader = CheckpointLoader; + +},{"./math/ndarray":24}],8:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var STATS_SAMPLE_PERCENTAGE = 0.1; +var InMemoryDataset = (function () { + function InMemoryDataset(dataShapes) { + this.dataShapes = dataShapes; + this.normalizationInfo = {}; + } + InMemoryDataset.prototype.getDataShape = function (dataIndex) { + return this.dataShapes[dataIndex]; + }; + InMemoryDataset.prototype.getData = function () { + return this.dataset; + }; + InMemoryDataset.prototype.getStats = function () { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + return this.dataset.map(function (d) { return _this.getStatsForData(d); }); + }; + InMemoryDataset.prototype.getStatsForData = function (data) { + var inputMin = Number.POSITIVE_INFINITY; + var inputMax = Number.NEGATIVE_INFINITY; + var exampleIndices = data.map(function (example, i) { return i; }); + util.shuffle(exampleIndices); + exampleIndices = + exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE); + for (var i = 0; i < exampleIndices.length; i++) { + var inputValues = data[exampleIndices[i]].getValues(); + for (var j = 0; j < inputValues.length; j++) { + inputMin = Math.min(inputMin, inputValues[j]); + inputMax = Math.max(inputMax, inputValues[j]); + } + } + return { + inputMin: inputMin, + inputMax: inputMax, + exampleCount: data.length, + shape: data[0].shape, + }; + }; + InMemoryDataset.prototype.normalizeExamplesToRange = function (examples, curLowerBounds, curUpperBounds, newLowerBounds, newUpperBounds) { + var curBoundsIsPerDimension = (curUpperBounds instanceof Float32Array && + curLowerBounds instanceof Float32Array); + var newBoundsIsPerDimension = (newLowerBounds instanceof Float32Array && + newUpperBounds instanceof Float32Array); + var inputSize = util.sizeFromShape(examples[0].shape); + var newExamples = []; + examples.forEach(function (example) { + var inputValues = example.getValues(); + var normalizedValues = new Float32Array(inputSize); + for (var j = 0; j < inputSize; j++) { + var curLowerBound = curBoundsIsPerDimension ? + curLowerBounds[j] : + curLowerBounds; + var curUpperBound = curBoundsIsPerDimension ? + curUpperBounds[j] : + curUpperBounds; + var curRange = curUpperBound - curLowerBound; + var newLowerBound = newBoundsIsPerDimension ? + newLowerBounds[j] : + newLowerBounds; + var newUpperBound = newBoundsIsPerDimension ? + newUpperBounds[j] : + newUpperBounds; + var newRange = newUpperBound - newLowerBound; + if (curRange === 0) { + normalizedValues[j] = newLowerBound; + } + else { + normalizedValues[j] = newLowerBound + + newRange * (inputValues[j] - curLowerBound) / curRange; + } + } + newExamples.push(ndarray_1.NDArray.make(example.shape, { values: normalizedValues })); + }); + return newExamples; + }; + InMemoryDataset.prototype.computeBounds = function (dataIndex) { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + var size = util.sizeFromShape(this.dataset[dataIndex][0].shape); + this.normalizationInfo[dataIndex] = { + isNormalized: false, + minValues: new Float32Array(size), + maxValues: new Float32Array(size) + }; + for (var i = 0; i < size; i++) { + this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY; + this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY; + } + this.dataset[dataIndex].forEach(function (example) { + var inputValues = example.getValues(); + for (var k = 0; k < size; k++) { + _this.normalizationInfo[dataIndex].minValues[k] = Math.min(_this.normalizationInfo[dataIndex].minValues[k], inputValues[k]); + _this.normalizationInfo[dataIndex].maxValues[k] = Math.max(_this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]); + } + }); + }; + InMemoryDataset.prototype.normalizeWithinBounds = function (dataIndex, lowerBound, upperBound) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + if (dataIndex >= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":24,"./util":88}],9:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":10,"./math/concat3d_util":17,"./math/conv_util":18,"./math/ndarray":24,"./util":88}],10:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":14}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":24,"./session":84}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":9,"./priority_queue":83}],13:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":7,"./dataset":8,"./graph":9,"./graph_runner":11,"./initializers":14,"./input_provider":15,"./math/conv_util":18,"./math/math":21,"./math/math_cpu":22,"./math/math_gpu":23,"./math/ndarray":24,"./math/webgl/gpgpu_context":37,"./math/webgl/gpgpu_util":38,"./math/webgl/render_ndarray_gpu_util":50,"./math/webgl/webgl_util":60,"./optimizer":82,"./session":84,"./sgd_optimizer":86,"./util":88}],14:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":24}],15:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":24,"./util":88}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":24}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":88}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":88}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],20:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":24}],21:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":88,"./concat3d_util":17,"./copy2d_util":19,"./ndarray":24}],22:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":18,"../util":88,"./concat3d_util":17,"./copy2d_util":19,"./math":21,"./ndarray":24}],23:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":88,"./concat3d_util":17,"./conv_util":18,"./math":21,"./ndarray":24,"./webgl/addscaledmat_gpu":25,"./webgl/addsubmuldiv_gpu":26,"./webgl/argmaxequals_gpu":27,"./webgl/argminmax_gpu":28,"./webgl/avg_pool_gpu":29,"./webgl/batchnorm_gpu":30,"./webgl/concat3d_gpu":32,"./webgl/conv_backprop_gpu":33,"./webgl/conv_gpu":34,"./webgl/copy_gpu":35,"./webgl/exp_gpu":36,"./webgl/gpgpu_context":37,"./webgl/gpgpu_util":38,"./webgl/log_gpu":39,"./webgl/logsumexp_gpu":40,"./webgl/max_pool_backprop_gpu":41,"./webgl/max_pool_gpu":42,"./webgl/min_pool_gpu":43,"./webgl/minmax_gpu":44,"./webgl/mulmat_gpu":45,"./webgl/neg_gpu":46,"./webgl/pool_gpu":47,"./webgl/reducesum_gpu":48,"./webgl/relu_gpu":49,"./webgl/reshape_gpu":51,"./webgl/resize_bilinear_gpu":52,"./webgl/shader_compiler":53,"./webgl/sigmoid_gpu":54,"./webgl/step_gpu":55,"./webgl/texture_manager":57,"./webgl/trig_gpu":58,"./webgl/webgl_util":60}],24:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":88,"./webgl/webgl_util":60}],25:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":37}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":21,"./binaryop_gpu":31}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":28}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":60}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":47}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":37}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":18}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":18,"./conv_gpu":34}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":18}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":59}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":38,"./tex_util":56,"./webgl_util":60}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":56,"./webgl_util":60}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":59}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":37}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":18}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":47}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":47}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":60}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":21,"./shader_compiler":53}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":59}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":18,"./webgl_util":60}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":37}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":59}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":60}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":88}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":18}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":88}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":59}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":59}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":59}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":37}],60:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":88}],61:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":9,"./graph_util":12,"./ops/add":62,"./ops/argmax":63,"./ops/argmaxequals":64,"./ops/concat3d":65,"./ops/convolution":66,"./ops/divide":67,"./ops/element_wise_activation":68,"./ops/element_wise_cost":69,"./ops/exp":70,"./ops/linear_combination":71,"./ops/log":72,"./ops/matmul":73,"./ops/max_pool":74,"./ops/multiply":75,"./ops/reduce_sum":77,"./ops/reshape":78,"./ops/softmax":79,"./ops/split":80,"./ops/subtract":81}],62:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":12,"../math/ndarray":24,"../util":88,"./op":76}],63:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":76}],64:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":76}],65:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":17,"./op":76}],66:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":18,"../util":88,"./op":76}],67:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":12,"../util":88,"./op":76}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":16,"./op":76}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":12,"../math/cost_functions":20,"../math/ndarray":24,"../util":88,"./op":76}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":12,"./op":76}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":12,"./op":76}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":12,"./op":76}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":12,"../math/math":21,"./op":76}],74:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":18,"../util":88,"./op":76}],75:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":12,"../util":88,"./op":76}],76:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],77:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":12,"../math/ndarray":24,"../util":88,"./op":76}],78:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":88,"./op":76}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":9,"../math/ndarray":24,"../util":88,"./op":76}],80:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":12,"../util":88,"./op":76}],81:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":12,"../math/ndarray":24,"../util":88,"./op":76}],82:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],83:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],84:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":24,"./operation_emitter":61,"./session_util":85,"./tensor_array_map":87,"./util":88}],85:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":9,"./graph_util":12,"./math/ndarray":24,"./util":88}],86:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":24,"./optimizer":82,"./session_util":85,"./tensor_array_map":87}],87:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],88:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[3]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","demos/demo-footer.ts","demos/demo-header.ts","demos/font-embedding/font-embedding.ts","demos/learnjs.ts","demos/ndarray-image-visualizer.ts","demos/polymer-spec.ts","src/checkpoint_loader.ts","src/dataset.ts","src/graph.ts","src/graph_layers.ts","src/graph_runner.ts","src/graph_util.ts","src/index.ts","src/initializers.ts","src/input_provider.ts","src/math/activation_functions.ts","src/math/concat3d_util.ts","src/math/conv_util.ts","src/math/copy2d_util.ts","src/math/cost_functions.ts","src/math/math.ts","src/math/math_cpu.ts","src/math/math_gpu.ts","src/math/ndarray.ts","src/math/webgl/addscaledmat_gpu.ts","src/math/webgl/addsubmuldiv_gpu.ts","src/math/webgl/argmaxequals_gpu.ts","src/math/webgl/argminmax_gpu.ts","src/math/webgl/avg_pool_gpu.ts","src/math/webgl/batchnorm_gpu.ts","src/math/webgl/binaryop_gpu.ts","src/math/webgl/concat3d_gpu.ts","src/math/webgl/conv_backprop_gpu.ts","src/math/webgl/conv_gpu.ts","src/math/webgl/copy_gpu.ts","src/math/webgl/exp_gpu.ts","src/math/webgl/gpgpu_context.ts","src/math/webgl/gpgpu_util.ts","src/math/webgl/log_gpu.ts","src/math/webgl/logsumexp_gpu.ts","src/math/webgl/max_pool_backprop_gpu.ts","src/math/webgl/max_pool_gpu.ts","src/math/webgl/min_pool_gpu.ts","src/math/webgl/minmax_gpu.ts","src/math/webgl/mulmat_gpu.ts","src/math/webgl/neg_gpu.ts","src/math/webgl/pool_gpu.ts","src/math/webgl/reducesum_gpu.ts","src/math/webgl/relu_gpu.ts","src/math/webgl/render_ndarray_gpu_util.ts","src/math/webgl/reshape_gpu.ts","src/math/webgl/resize_bilinear_gpu.ts","src/math/webgl/shader_compiler.ts","src/math/webgl/sigmoid_gpu.ts","src/math/webgl/step_gpu.ts","src/math/webgl/tex_util.ts","src/math/webgl/texture_manager.ts","src/math/webgl/trig_gpu.ts","src/math/webgl/unaryop_gpu.ts","src/math/webgl/webgl_util.ts","src/operation_emitter.ts","src/ops/add.ts","src/ops/argmax.ts","src/ops/argmaxequals.ts","src/ops/concat3d.ts","src/ops/convolution.ts","src/ops/divide.ts","src/ops/element_wise_activation.ts","src/ops/element_wise_cost.ts","src/ops/exp.ts","src/ops/linear_combination.ts","src/ops/log.ts","src/ops/matmul.ts","src/ops/max_pool.ts","src/ops/multiply.ts","src/ops/op.ts","src/ops/reduce_sum.ts","src/ops/reshape.ts","src/ops/softmax.ts","src/ops/split.ts","src/ops/subtract.ts","src/optimizer.ts","src/priority_queue.ts","src/session.ts","src/session_util.ts","src/sgd_optimizer.ts","src/tensor_array_map.ts","src/util.ts"],"names":[],"mappings":"AAAA;ACcA,OAAO,CAAC,EAAC,EAAE,EAAE,aAAa,EAAC,CAAC,CAAC;;;ACA7B,OAAO,CAAC,EAAC,EAAE,EAAE,aAAa,EAAC,CAAC,CAAC;;;;;;;;;;;;;;;ACC7B,uCAAqC;AACrC,0BAAwB;AACxB,0BAAwB;AAExB,sCAA+I;AAG/I,gDAAmE;AAEnE,IAAM,wBAAwB,GAC1B,6DAA6D,CAAC;AAGvD,QAAA,oBAAoB,GAAG,6BAAc,CAAC;IAC/C,EAAE,EAAE,gBAAgB;IACpB,UAAU,EAAE;QACV,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,MAAM;QACd,SAAS,EAAE,KAAK;QAChB,kBAAkB,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAC;KAC9D;CACF,CAAC,CAAC;AAOH;IAAmC,iCAAoB;IAAvD;;IAuKA,CAAC;IAhJC,6BAAK,GAAL;QAAA,iBAmCC;QAlCC,IAAM,gBAAgB,GAClB,IAAI,0BAAgB,CAAC,wBAAwB,GAAG,QAAQ,CAAC,CAAC;QAC9D,gBAAgB,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,UAAA,SAAS;YAC/C,KAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,KAAI,CAAC,UAAU,EAAE,CAAC;YAClB,KAAI,CAAC,KAAK,CAAC,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAGH,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;QACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QAClD,CAAC;QACD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;QACvD,CAAC;QACD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAEhB,IAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,CAAqB,CAAC;QACzE,aAAa,CAAC,gBAAgB,CAAC,QAAQ,EAAE,UAAC,CAAC;YACzC,KAAI,CAAC,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC;YAClC,KAAI,CAAC,SAAS,CAAC,KAAI,CAAC,MAAM,CAAC,CAAC;YAC5B,KAAI,CAAC,KAAK,CAAC,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,IAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,CAAqB,CAAC;QACzE,aAAa,CAAC,gBAAgB,CAAC,QAAQ,EAAE,UAAC,CAAC;YACzC,KAAI,CAAC,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC;YAChC,KAAI,CAAC,KAAK,CAAC,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAS,GAAT,UAAU,MAAc;QAEtB,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC;YAC1D,MAAM,CAAC;QACT,CAAC;QAGD,IAAM,SAAS,GAA2B,EAAE,CAAC;QAC7C,IAAM,gBAAgB,GAClB,IAAI,CAAC,SAAS,CAAC,mDAAmD,CAAC,CAAC;QACxE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACnD,IAAM,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YAC7C,SAAS,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAC,CAAC,CAAC;QACxC,CAAC;QAEA,IAAY,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED,oCAAY,GAAZ,UAAa,CAAQ;QACnB,IAAM,OAAO,GAAG,CAAC,CAAC,MAA4B,CAAC;QAC/C,IAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,YAAY,CAAE,EAAE,EAAE,CAAC,CAAC;QAEhE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,GAAI,OAAe,CAAC,cAAc,CAAC;QAE5D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAED,kCAAU,GAAV;QACE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,GAA6B,CAAC;QAChD,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAE3B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE5B,IAAM,QAAQ,GAAG,iCAAiC,CAAC;QACnD,IAAM,QAAQ,GAAG,gCAAgC,CAAC;QAClD,IAAM,QAAQ,GAAG,iCAAiC,CAAC;QACnD,IAAM,QAAQ,GAAG,gCAAgC,CAAC;QAClD,IAAM,QAAQ,GAAG,iCAAiC,CAAC;QACnD,IAAM,QAAQ,GAAG,gCAAgC,CAAC;QAClD,IAAM,QAAQ,GAAG,iCAAiC,CAAC;QACnD,IAAM,QAAQ,GAAG,gCAAgC,CAAC;QAClD,IAAM,QAAQ,GAAG,yBAAyB,CAAC;QAC3C,IAAM,QAAQ,GAAG,wBAAwB,CAAC;QAE1C,IAAI,CAAC,KAAK,GAAG,IAAI,eAAK,EAAE,CAAC;QACzB,IAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QACrB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAEjD,IAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAC1D,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAT,CAAS,EAAE,IAAI,EACtB,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAChD,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtD,IAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAT,CAAS,EAAE,IAAI,EACvE,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAChD,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtD,IAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAT,CAAS,EAAE,IAAI,EACvE,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAChD,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtD,IAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAT,CAAS,EAAE,IAAI,EACvE,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAChD,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAC9B,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAZ,CAAY,EACpE,IAAI,EAAE,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EACtD,IAAI,4BAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAEtD,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAc,EAAE,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAO,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED,6BAAK,GAAL,UAAM,MAAc,EAAE,IAAY;QAAlC,iBA+BC;QA9BC,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK;YACrD,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,CAAC;QACT,CAAC;QACD,IAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,MAAM,CAAC;QACT,CAAC;QAED,IAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;aAC5C,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QACrD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAEnB,IAAM,SAAS,GACX,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAC,QAA8B,IAAK,OAAA,QAAQ,CAAC,GAAG,EAAZ,CAAY,CAAC,CAAC;QAEzE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI,EAAE,KAAK;YAC1B,IAAM,SAAS,GAAG,KAAK,CAAC,iBAAO,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAE/D,IAAM,KAAK,GAAG,KAAI,CAAC,OAAO,CAAC,IAAI,CAC3B,KAAI,CAAC,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,KAAI,CAAC,WAAW,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAC,CAAC;YAItE,IAAM,MAAM,GAAG,KAAK,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YACtC,IAAM,MAAM,GAAG,KAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACzD,IAAM,QAAQ,GAAG,KAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAC5D,KAAI,CAAC,GAAG,CAAC,wBAAwB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YAC5D,KAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IACH,oBAAC;AAAD,CAvKA,AAuKC,CAvKkC,4BAAoB,GAuKtD;AAvKY,sCAAa;AAwK1B,QAAQ,CAAC,eAAe,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,aAAa,CAAC,CAAC;;;;;;;;AClMpE,kCAA6B;;;;;;;;;;;;;;;ACC7B,+CAAkE;AAGvD,QAAA,6BAA6B,GACpC,6BAAc,CAAC,EAAC,EAAE,EAAE,0BAA0B,EAAE,UAAU,EAAE,EAAE,EAAC,CAAC,CAAC;AAErE;IAA4C,0CAA6B;IAAzE;;IA+DA,CAAC;IA1DC,sCAAK,GAAL;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAsB,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,aAAa;YACd,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAA6B,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;IACrC,CAAC;IAED,yCAAQ,GAAR,UAAS,KAAe;QACtB,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;IAED,wCAAO,GAAP,UAAQ,KAAa,EAAE,MAAc;QACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3C,CAAC;IAED,yDAAwB,GAAxB,UAAyB,OAAgB;QACvC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAC/C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC3C,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3B,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;QACvC,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,iDAAgB,GAAhB,UAAiB,OAAgB;QAC/B,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC1C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,GAAG,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED,uDAAsB,GAAtB,UAAuB,OAAgB;QACrC,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC1C,IAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBACnC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,GAAG,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED,qCAAI,GAAJ;QACE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;QAC/B,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACxD,CAAC;IACH,6BAAC;AAAD,CA/DA,AA+DC,CA/D2C,qCAA6B,GA+DxE;AA/DY,wDAAsB;AAgEnC,QAAQ,CAAC,eAAe,CACpB,sBAAsB,CAAC,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC,CAAC;;;;;AC/BjE,wBAA+B,IAAU;IAEvC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAW,CAAiC,CAAC;AACpE,CAAC;AAHD,wCAGC;;;;;AC9CD,0CAAuC;AAiBvC,IAAM,aAAa,GAAG,eAAe,CAAC;AAEtC;IAIE,0BAAoB,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;QACjC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;YACzD,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;QACtB,CAAC;IACH,CAAC;IAEO,uCAAY,GAApB;QAAA,iBAeC;QAdC,MAAM,CAAC,IAAI,OAAO,CAAO,UAAC,OAAO,EAAE,MAAM;YACvC,IAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAI,CAAC,OAAO,GAAG,aAAa,CAAC,CAAC;YAE9C,GAAG,CAAC,MAAM,GAAG;gBACX,KAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBACvD,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,GAAG,CAAC,OAAO,GAAG,UAAC,KAAK;gBAClB,MAAM,IAAI,KAAK,CACR,aAAa,sBAAiB,KAAI,CAAC,OAAO,OAAI,GAAG,KAAK,CAAC,CAAC;YACjE,CAAC,CAAC;YACF,GAAG,CAAC,IAAI,EAAE,CAAC;QACb,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gDAAqB,GAArB;QAAA,iBAWC;QAVC,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC;YACpC,MAAM,CAAC,IAAI,OAAO,CAAqB,UAAC,OAAO,EAAE,MAAM;gBACrD,KAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC;oBACvB,OAAO,CAAC,KAAI,CAAC,kBAAkB,CAAC,CAAC;gBACnC,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAqB,UAAC,OAAO,EAAE,MAAM;YACrD,OAAO,CAAC,KAAI,CAAC,kBAAkB,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0CAAe,GAAf;QAAA,iBA0BC;QAzBC,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC;YAC3B,MAAM,CAAC,IAAI,OAAO,CAA+B,UAAC,OAAO,EAAE,MAAM;gBAC/D,OAAO,CAAC,KAAI,CAAC,SAAS,CAAC,CAAC;YAC1B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,CAAC,IAAI,OAAO,CAA+B,UAAC,OAAO,EAAE,MAAM;YAC/D,KAAI,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAC7B,UAAC,oBAAwC;gBACvC,IAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,KAAI,CAAC,kBAAkB,CAAC,CAAC;gBAE3D,IAAM,gBAAgB,GAA4B,EAAE,CAAC;gBACrD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC9C,gBAAgB,CAAC,IAAI,CAAC,KAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5D,CAAC;gBAED,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,UAAA,SAAS;oBAC1C,KAAI,CAAC,SAAS,GAAG,EAAE,CAAC;oBACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;wBAC1C,KAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;oBAClD,CAAC;oBACD,OAAO,CAAC,KAAI,CAAC,SAAS,CAAC,CAAC;gBAC1B,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACT,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sCAAW,GAAX,UAAY,OAAe;QAA3B,iBAiCC;QAhCC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,oCAAoC,GAAG,OAAO,CAAC,CAAC;QAClE,CAAC;QAED,IAAM,4BAA4B,GAC9B,UAAC,OAAmC,EAAE,MAAkB;YACtD,IAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,GAAG,CAAC,YAAY,GAAG,aAAa,CAAC;YACjC,IAAM,KAAK,GAAG,KAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC;YACxD,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;YAEtC,GAAG,CAAC,MAAM,GAAG;gBACX,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC9C,IAAM,OAAO,GACT,iBAAO,CAAC,IAAI,CAAC,KAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,QAAA,EAAC,CAAC,CAAC;gBACnE,OAAO,CAAC,OAAO,CAAC,CAAC;YACnB,CAAC,CAAC;YACF,GAAG,CAAC,OAAO,GAAG,UAAC,KAAK;gBAClB,MAAM,IAAI,KAAK,CACX,2BAA2B,GAAG,OAAO,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC;YAC5D,CAAC,CAAC;YACF,GAAG,CAAC,IAAI,EAAE,CAAC;QACb,CAAC,CAAC;QAEN,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC;YACpC,MAAM,CAAC,IAAI,OAAO,CAAU,UAAC,OAAO,EAAE,MAAM;gBAC1C,KAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC;oBACvB,IAAI,OAAO,CAAU,4BAA4B,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACnE,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAU,4BAA4B,CAAC,CAAC;IAC5D,CAAC;IACH,uBAAC;AAAD,CAtGA,AAsGC,IAAA;AAtGY,4CAAgB;;;;;AClB7B,0CAAuC;AACvC,6BAA+B;AAE/B,IAAM,uBAAuB,GAAG,GAAG,CAAC;AAsBpC;IAOE,yBAAsB,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;QAC1C,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED,sCAAY,GAAZ,UAAa,SAAiB;QAC5B,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAID,iCAAO,GAAP;QACE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,kCAAQ,GAAR;QAAA,iBAMC;QALC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAvB,CAAuB,CAAC,CAAC;IACxD,CAAC;IAGO,yCAAe,GAAvB,UAAwB,IAAe;QACrC,IAAI,QAAQ,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACxC,IAAI,QAAQ,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAExC,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,UAAC,OAAO,EAAE,CAAC,IAAK,OAAA,CAAC,EAAD,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAC7B,cAAc;YACV,cAAc,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,uBAAuB,CAAC,CAAC;QAE1E,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,IAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;YACxD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5C,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9C,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;QAED,MAAM,CAAC;YACL,QAAQ,UAAA;YACR,QAAQ,UAAA;YACR,YAAY,EAAE,IAAI,CAAC,MAAM;YACzB,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK;SACrB,CAAC;IACJ,CAAC;IAaO,kDAAwB,GAAhC,UACI,QAAmB,EAAE,cAAmC,EACxD,cAAmC,EAAE,cAAmC,EACxE,cAAmC;QACrC,IAAM,uBAAuB,GACzB,CAAC,cAAc,YAAY,YAAY;YACtC,cAAc,YAAY,YAAY,CAAC,CAAC;QAC7C,IAAM,uBAAuB,GACzB,CAAC,cAAc,YAAY,YAAY;YACtC,cAAc,YAAY,YAAY,CAAC,CAAC;QAE7C,IAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACxD,IAAM,WAAW,GAAc,EAAE,CAAC;QAElC,QAAQ,CAAC,OAAO,CAAC,UAAA,OAAO;YACtB,IAAM,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;YACxC,IAAM,gBAAgB,GAAG,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC;YACrD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;gBACnC,IAAM,aAAa,GAAG,uBAAuB;oBACxC,cAA+B,CAAC,CAAC,CAAC;oBACnC,cAAwB,CAAC;gBAC7B,IAAM,aAAa,GAAG,uBAAuB;oBACxC,cAA+B,CAAC,CAAC,CAAC;oBACnC,cAAwB,CAAC;gBAC7B,IAAM,QAAQ,GAAG,aAAa,GAAG,aAAa,CAAC;gBAE/C,IAAM,aAAa,GAAG,uBAAuB;oBACxC,cAA+B,CAAC,CAAC,CAAC;oBACnC,cAAwB,CAAC;gBAC7B,IAAM,aAAa,GAAG,uBAAuB;oBACxC,cAA+B,CAAC,CAAC,CAAC;oBACnC,cAAwB,CAAC;gBAC7B,IAAM,QAAQ,GAAG,aAAa,GAAG,aAAa,CAAC;gBAE/C,EAAE,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC;oBACnB,gBAAgB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC;gBACtC,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,gBAAgB,CAAC,CAAC,CAAC,GAAG,aAAa;wBAC/B,QAAQ,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,GAAG,QAAQ,CAAC;gBAC7D,CAAC;YACH,CAAC;YACD,WAAW,CAAC,IAAI,CAAC,iBAAO,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,gBAAgB,EAAC,CAAC,CAAC,CAAC;QAC5E,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,WAAW,CAAC;IACrB,CAAC;IAEO,uCAAa,GAArB,UAAsB,SAAiB;QAAvC,iBA4BC;QA3BC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QAED,IAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAGlE,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,GAAG;YAClC,YAAY,EAAE,KAAK;YACnB,SAAS,EAAE,IAAI,YAAY,CAAC,IAAI,CAAC;YACjC,SAAS,EAAE,IAAI,YAAY,CAAC,IAAI,CAAC;SAClC,CAAC;QAEF,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,iBAAiB,CAAC;YAC1E,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAC5E,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,UAAA,OAAO;YACrC,IAAM,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;YACxC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC9B,KAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CACrD,KAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;gBACpE,KAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CACrD,KAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YACtE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,+CAAqB,GAArB,UACI,SAAiB,EAAE,UAAkB,EAAE,UAAkB;QAC3D,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QACD,EAAE,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QAED,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;YAC9C,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;QAKD,IAAI,cAAmC,CAAC;QACxC,IAAI,cAAmC,CAAC;QAExC,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;YACnD,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,CAAC;YAC/D,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,CAAC;QACjE,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC;YAC7D,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC;QAC/D,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,CACnD,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,cAAc,EAAE,cAAc,EAAE,UAAU,EACnE,UAAU,CAAC,CAAC;QAChB,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,YAAY,GAAG,IAAI,CAAC;QACtD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,UAAU,CAAC;QAC1D,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,UAAU,CAAC;IAC5D,CAAC;IAEO,sCAAY,GAApB,UAAqB,SAAiB;QACpC,MAAM,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI;YACjC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC;IACrD,CAAC;IAED,6CAAmB,GAAnB,UAAoB,SAAiB;QACnC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QAED,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAClC,MAAM,CAAC;QACT,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,CACnD,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,EACtE,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,EAC7C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,EAC3C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC;QACjD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,YAAY,GAAG,KAAK,CAAC;IACzD,CAAC;IAED,6CAAmB,GAAnB,UAAoB,QAAmB,EAAE,SAAiB;QACxD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAClC,MAAM,CAAC,QAAQ,CAAC;QAClB,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,wBAAwB,CAChC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,EACvD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,UAAW,EAC7C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,EAC3C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;IAED,iCAAO,GAAP;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,CAAC;QACT,CAAC;QAED,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAChD,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;YAC/B,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IACH,sBAAC;AAAD,CA/NA,AA+NC,IAAA;AA/NqB,0CAAe;;;;;;;;;;;;;;;AC1BrC,+CAA2C;AAC3C,oDAAsD;AACtD,4CAA8C;AAC9C,0CAA+C;AAC/C,6BAA+B;AAM/B;IAGE;QAkSQ,UAAK,GAAW,EAAE,CAAC;QAjSzB,IAAI,CAAC,MAAM,GAAG,IAAI,0BAAW,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IAUD,wBAAQ,GAAR,UAAS,IAAY,EAAE,IAAa;QAClC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACzE,CAAC;IAWD,2BAAW,GAAX,UAAY,IAAY,EAAE,KAAe;QACvC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAC7E,CAAC;IAOD,wBAAQ,GAAR,UAAS,KAAgB;QACvB,IAAI,UAAmB,CAAC;QACxB,EAAE,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC;YAC9B,UAAU,GAAG,gBAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,YAAY,iBAAO,CAAC,CAAC,CAAC;YACpC,UAAU,GAAG,KAAK,CAAC;QACrB,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC;YAClC,IAAM,IAAI,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;YACnD,UAAU,GAAG,iBAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAC;QACpE,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;IACzE,CAAC;IAQD,uBAAO,GAAP,UAAQ,CAAS,EAAE,KAAe;QAChC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAC9B,IAAI,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IAClD,CAAC;IAUD,sCAAsB,GAAtB,UAAuB,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QAEnE,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAC9B,IAAI,0BAA0B,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;IASD,mBAAG,GAAH,UAAI,EAAU,EAAE,EAAU;QACxB,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAChE,CAAC;IASD,wBAAQ,GAAR,UAAS,EAAU,EAAE,EAAU;QAC7B,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACrE,CAAC;IASD,wBAAQ,GAAR,UAAS,EAAU,EAAE,EAAU;QAC7B,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACrE,CAAC;IASD,sBAAM,GAAN,UAAO,EAAU,EAAE,EAAU;QAC3B,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;IAMD,yBAAS,GAAT,UAAU,CAAS;QACjB,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAQD,wBAAQ,GAAR,UAAS,EAAU,EAAE,EAAU,EAAE,IAAY;QAC3C,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;IAC3E,CAAC;IAQD,sBAAM,GAAN,UAAO,EAAU,EAAE,EAAU;QAC3B,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;IAaD,sBAAM,GAAN,UACI,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,SAAiB,EAAE,WAAmB,EACvE,MAAU,EAAE,OAAgB;QAA5B,uBAAA,EAAA,UAAU;QACZ,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,iBAAiB,CACpD,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC/D,CAAC;IAUD,uBAAO,GAAP,UAAQ,CAAS,EAAE,SAAiB,EAAE,MAAU,EAAE,OAAgB;QAA5B,uBAAA,EAAA,UAAU;QAC9C,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAC9B,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5D,CAAC;IAOD,mBAAG,GAAH,UAAI,CAAS;QACX,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;IAOD,mBAAG,GAAH,UAAI,CAAS;QACX,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;IAOD,oBAAI,GAAJ,UAAK,CAAS;QACZ,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IAOD,oBAAI,GAAJ,UAAK,CAAS;QACZ,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IAOD,uBAAO,GAAP,UAAQ,CAAS;QACf,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAMD,sBAAM,GAAN,UAAO,CAAS;QACd,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAQD,uBAAO,GAAP,UAAQ,CAAS;QACf,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAOD,uCAAuB,GAAvB,UAAwB,CAAS,EAAE,MAAc;QAC/C,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAC9B,IAAI,2BAA2B,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAQD,+BAAe,GAAf,UAAgB,KAAa,EAAE,UAAkB;QAC/C,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAC9B,IAAI,mBAAmB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;IACxD,CAAC;IAOD,sBAAM,GAAN,UAAO,CAAS;QACd,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAQD,4BAAY,GAAZ,UAAa,EAAU,EAAE,EAAU;QACjC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACzE,CAAC;IAEO,sCAAsB,GAA9B,UAA+B,IAAU;QACvC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,wBAAQ,GAAR;QACE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAGH,YAAC;AAAD,CAtSA,AAsSC,IAAA;AAtSY,sBAAK;AA+SlB;IAME,gBAAmB,KAAe;QAAf,UAAK,GAAL,KAAK,CAAU;QAChC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAEH,aAAC;AAAD,CAVA,AAUC;AADgB,aAAM,GAAG,CAAC,CAAC;AATf,wBAAM;AAmBnB;IAQE,cACW,KAAY,EAAS,IAAY,EACjC,MAAgC,EAAS,MAAc;QADvD,UAAK,GAAL,KAAK,CAAO;QAAS,SAAI,GAAJ,IAAI,CAAQ;QACjC,WAAM,GAAN,MAAM,CAA0B;QAAS,WAAM,GAAN,MAAM,CAAQ;QAChE,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAIH,WAAC;AAAD,CAjBA,AAiBC;AADgB,WAAM,GAAG,CAAC,CAAC;AAhBN,oBAAI;AAyB1B;IAAkC,gCAAI;IACpC,sBAAY,KAAY,EAAE,IAAY,EAAS,IAAa;QAA5D,YACE,kBAAM,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,SAC/C;QAF8C,UAAI,GAAJ,IAAI,CAAS;;IAE5D,CAAC;IACD,+BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,IAAI,IAAI,IAAI,EACjB,gDAAgD,GAAG,IAAI,CAAC,IAAI;YACxD,yBAAyB,CAAC,CAAC;IACrC,CAAC;IACH,mBAAC;AAAD,CAVA,AAUC,CAViC,IAAI,GAUrC;AAVY,oCAAY;AAkBzB;IAAqC,mCAAI;IACvC,yBAAY,KAAY,EAAE,IAAY,EAAE,KAAe;eACrD,kBAAM,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,kCAAQ,GAAR,cAAY,CAAC;IACf,sBAAC;AAAD,CALA,AAKC,CALoC,IAAI,GAKxC;AALY,0CAAe;AAY5B;IAAkC,gCAAI;IACpC,sBAAY,KAAY,EAAS,IAAa;QAA9C,YACE,kBAAM,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,SACrD;QAFgC,UAAI,GAAJ,IAAI,CAAS;;IAE9C,CAAC;IACD,+BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,IAAI,IAAI,IAAI,EACjB,gDAAgD,GAAG,IAAI,CAAC,IAAI;YACxD,yBAAyB,CAAC,CAAC;IACrC,CAAC;IACH,mBAAC;AAAD,CAVA,AAUC,CAViC,IAAI,GAUrC;AAVY,oCAAY;AAiBzB;IAAiC,+BAAI;IAEnC,qBACI,KAAY,EAAS,IAAY,EAAU,CAAS,EAC5C,KAAe;QAF3B,YAGE,kBAAM,KAAK,EAAE,IAAI,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,SAC3C;QAHwB,UAAI,GAAJ,IAAI,CAAQ;QAAU,OAAC,GAAD,CAAC,CAAQ;QAC5C,WAAK,GAAL,KAAK,CAAU;;IAE3B,CAAC;IACD,8BAAQ,GAAR;QACE,IAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,CACP,KAAK,KAAK,SAAS,EACnB,4DAA4D;YACxD,IAAI,CAAC,IAAI,GAAG,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK;YAC1C,2CAA2C,GAAG,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;IAC1E,CAAC;IACH,kBAAC;AAAD,CAhBA,AAgBC,CAhBgC,IAAI;AACnB,aAAC,GAAG,GAAG,CAAC;AADb,kCAAW;AAsBxB;IAAgD,8CAAI;IAKlD,oCACI,KAAY,EAAU,EAAU,EAAU,EAAU,EAAU,EAAU,EAChE,EAAU;QAFtB,YAGE,kBAAM,KAAK,EAAE,oBAAoB,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAE,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EAAE,IAAI,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,SAC3E;QAHyB,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;QAChE,QAAE,GAAF,EAAE,CAAQ;;IAEtB,CAAC;IAED,6CAAQ,GAAR;QACE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACrD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvC,MAAM,IAAI,KAAK,CACX,+DAA+D;gBAC/D,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QACD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvC,MAAM,IAAI,KAAK,CACX,+DAA+D;gBAC/D,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACH,iCAAC;AAAD,CAxBA,AAwBC,CAxB+C,IAAI;AAClC,6BAAE,GAAG,IAAI,CAAC;AACV,6BAAE,GAAG,IAAI,CAAC;AACV,6BAAE,GAAG,IAAI,CAAC;AACV,6BAAE,GAAG,IAAI,CAAC;AAJf,gEAA0B;AA6BvC;IAA6B,2BAAI;IAI/B,iBAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBACI,KAAK,EAAE,KAAK,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EACtB,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,SAC1E;QAJiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAIhE,CAAC;IAED,0BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAClD,qEAAqE;YACjE,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;YACnD,cAAc,CAAC,CAAC;IAC1B,CAAC;IACH,cAAC;AAAD,CAnBA,AAmBC,CAnB4B,IAAI;AACf,UAAE,GAAG,IAAI,CAAC;AACV,UAAE,GAAG,IAAI,CAAC;AAFf,0BAAO;AAwBpB;IAAkC,gCAAI;IAIpC,sBAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBACI,KAAK,EAAE,UAAU,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EAC3B,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,SAC1E;QAJiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAIhE,CAAC;IAED,+BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAClD,gEAAgE;YAC5D,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;YACnD,cAAc,CAAC,CAAC;IAC1B,CAAC;IACH,mBAAC;AAAD,CAnBA,AAmBC,CAnBiC,IAAI;AACpB,eAAE,GAAG,IAAI,CAAC;AACV,eAAE,GAAG,IAAI,CAAC;AAFf,oCAAY;AAwBzB;IAAkC,gCAAI;IAIpC,sBAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBACI,KAAK,EAAE,UAAU,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EAC3B,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,SAC1E;QAJiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAIhE,CAAC;IAED,+BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAClD,gEAAgE;YAC5D,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;YACnD,cAAc,CAAC,CAAC;IAC1B,CAAC;IACH,mBAAC;AAAD,CAnBA,AAmBC,CAnBiC,IAAI;AACpB,eAAE,GAAG,IAAI,CAAC;AACV,eAAE,GAAG,IAAI,CAAC;AAFf,oCAAY;AAwBzB;IAAgC,8BAAI;IAIlC,oBAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBACI,KAAK,EAAE,QAAQ,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EACzB,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,SAC1E;QAJiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAIhE,CAAC;IAED,6BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAClD,8DAA8D;YAC1D,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;YACnD,cAAc,CAAC,CAAC;IAC1B,CAAC;IACH,iBAAC;AAAD,CAnBA,AAmBC,CAnB+B,IAAI;AAClB,aAAE,GAAG,IAAI,CAAC;AACV,aAAE,GAAG,IAAI,CAAC;AAFf,gCAAU;AAwBvB;IAAmC,iCAAI;IAGrC,uBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,WAAW,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC;IAED,gCAAQ,GAAR,cAAY,CAAC;IACf,oBAAC;AAAD,CARA,AAQC,CARkC,IAAI;AACrB,eAAC,GAAG,GAAG,CAAC;AADb,sCAAa;AAc1B;IAAkC,gCAAI;IAIpC,sBACI,KAAY,EAAU,EAAU,EAAU,EAAU,EAC7C,IAAY;QAFvB,YAGE,kBACI,KAAK,EAAE,UAAU,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EAC3B,IAAI,MAAM,CAAC,aAAa,CAAC,0BAA0B,CAC/C,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,SACpC;QANyB,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;QAC7C,UAAI,GAAJ,IAAI,CAAQ;;IAKvB,CAAC;IACD,+BAAQ,GAAR;QACE,aAAa,CAAC,yBAAyB,CACnC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IACH,mBAAC;AAAD,CAhBA,AAgBC,CAhBiC,IAAI;AACpB,eAAE,GAAG,IAAI,CAAC;AACV,eAAE,GAAG,IAAI,CAAC;AACV,iBAAI,GAAG,MAAM,CAAC;AAHnB,oCAAY;AAkBzB,8BAA8B,OAAiB,EAAE,OAAiB;IAChE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QACjD,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACb,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IACD,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC;AAMD;IAAgC,8BAAI;IAGlC,oBAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBACI,KAAK,EAAE,QAAQ,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EACzB,IAAI,MAAM,CAAC,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,SAC1D;QAJiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAIhE,CAAC;IAED,6BAAQ,GAAR;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YAC7D,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EACrC,+DAA+D;gBAC3D,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC;QACpE,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EACrC,gEAAgE;gBAC5D,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,wCAAwC;gBACxD,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAC/B,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EACrC,oDAAoD,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;gBAChE,6CAA6C;gBAC7C,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAC1C,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,MAAM,IAAI,KAAK,CACX,6DAA6D,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IACH,iBAAC;AAAD,CAhCA,AAgCC,CAhC+B,IAAI;AAClB,aAAE,GAAG,IAAI,CAAC;AACV,aAAE,GAAG,IAAI,CAAC;AAFf,gCAAU;AAsCvB;IAAuC,qCAAI;IAIzC,2BACI,KAAY,EAAU,CAAS,EAAU,CAAS,EAAU,CAAS,EAC9D,SAAiB,EAAS,WAAmB,EAAS,MAAU,EAChE,OAAgB;QADsC,uBAAA,EAAA,UAAU;QAF3E,YAIE,kBACI,KAAK,EAAE,gBAAgB,EAAE,EAAC,CAAC,GAAA,EAAE,CAAC,GAAA,EAAE,CAAC,GAAA,EAAC,EAClC,IAAI,MAAM,CAAC,SAAS,CAAC,oBAAoB,CACrC,CAAC,CAAC,KAAiC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EACnE,OAAO,CAAC,CAAC,CAAC,SACnB;QARyB,OAAC,GAAD,CAAC,CAAQ;QAAU,OAAC,GAAD,CAAC,CAAQ;QAAU,OAAC,GAAD,CAAC,CAAQ;QAC9D,eAAS,GAAT,SAAS,CAAQ;QAAS,iBAAW,GAAX,WAAW,CAAQ;QAAS,YAAM,GAAN,MAAM,CAAI;QAChE,aAAO,GAAP,OAAO,CAAS;;IAM3B,CAAC;IACD,oCAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EACzB,kEAAkE;YAC9D,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EACzB,oEAAoE;YAChE,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EACzB,mEAAmE;YAC/D,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAE5B,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EACnC,0CAA0C,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACxD,wCAAwC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC7E,CAAC;IACH,wBAAC;AAAD,CAjCA,AAiCC,CAjCsC,IAAI;AACzB,mBAAC,GAAG,GAAG,CAAC;AACR,mBAAC,GAAG,GAAG,CAAC;AACR,mBAAC,GAAG,GAAG,CAAC;AAHb,8CAAiB;AAuC9B;IAAiC,+BAAI;IAEnC,qBACI,KAAY,EAAU,CAAS,EAAS,SAAiB,EAClD,MAAU,EAAS,OAAgB;QAAnC,uBAAA,EAAA,UAAU;QAFrB,YAGE,kBACI,KAAK,EAAE,UAAU,EAAE,EAAC,CAAC,GAAA,EAAC,EACtB,IAAI,MAAM,CAAC,SAAS,CAAC,oBAAoB,CACrC,CAAC,CAAC,KAAiC,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAClE,OAAO,CAAC,CAAC,CAAC,SACnB;QAPyB,OAAC,GAAD,CAAC,CAAQ;QAAS,eAAS,GAAT,SAAS,CAAQ;QAClD,YAAM,GAAN,MAAM,CAAI;QAAS,aAAO,GAAP,OAAO,CAAS;;IAM9C,CAAC;IACD,8BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EACzB,mEAAmE;YAC/D,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;IAC9B,CAAC;IACH,kBAAC;AAAD,CAjBA,AAiBC,CAjBgC,IAAI;AACnB,aAAC,GAAG,GAAG,CAAC;AADb,kCAAW;AAuBxB;IAA8B,4BAAI;IAEhC,kBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,MAAM,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IACD,2BAAQ,GAAR,cAAY,CAAC;IACf,eAAC;AAAD,CANA,AAMC,CAN6B,IAAI;AAChB,UAAC,GAAG,GAAG,CAAC;AADb,4BAAQ;AAYrB;IAA6B,2BAAI;IAE/B,iBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,KAAK,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IACD,0BAAQ,GAAR,cAAY,CAAC;IACf,cAAC;AAAD,CANA,AAMC,CAN4B,IAAI;AACf,SAAC,GAAG,GAAG,CAAC;AADb,0BAAO;AAYpB;IAA6B,2BAAI;IAE/B,iBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,KAAK,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IACD,0BAAQ,GAAR,cAAY,CAAC;IACf,cAAC;AAAD,CANA,AAMC,CAN4B,IAAI;AACf,SAAC,GAAG,GAAG,CAAC;AADb,0BAAO;AAYpB;IAA8B,4BAAI;IAEhC,kBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,MAAM,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IACD,2BAAQ,GAAR,cAAY,CAAC;IACf,eAAC;AAAD,CANA,AAMC,CAN6B,IAAI;AAChB,UAAC,GAAG,GAAG,CAAC;AADb,4BAAQ;AAYrB;IAAiC,+BAAI;IAEnC,qBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,SAAS,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IACD,8BAAQ,GAAR,cAAY,CAAC;IACf,kBAAC;AAAD,CANA,AAMC,CANgC,IAAI;AACnB,aAAC,GAAG,GAAG,CAAC;AADb,kCAAW;AAYxB;IAAgC,8BAAI;IAElC,oBAAY,KAAY,EAAE,CAAS;eACjC,kBAAM,KAAK,EAAE,QAAQ,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IACD,6BAAQ,GAAR,cAAY,CAAC;IACf,iBAAC;AAAD,CANA,AAMC,CAN+B,IAAI;AAClB,YAAC,GAAG,GAAG,CAAC;AADb,gCAAU;AAavB;IAAiD,+CAAI;IAGnD,qCAAY,KAAY,EAAU,CAAS,EAAU,MAAc;QAAnE,YACE,kBAAM,KAAK,EAAE,yBAAyB,EAAE,EAAC,CAAC,GAAA,EAAE,MAAM,QAAA,EAAC,EAAE,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC,SACrE;QAFiC,OAAC,GAAD,CAAC,CAAQ;QAAU,YAAM,GAAN,MAAM,CAAQ;;IAEnE,CAAC;IACD,8CAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EACjD,oDAAoD,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK;YAC/D,6BAA6B,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IACpE,CAAC;IACH,kCAAC;AAAD,CAZA,AAYC,CAZgD,IAAI;AACnC,6BAAC,GAAG,GAAG,CAAC;AACR,kCAAM,GAAG,QAAQ,CAAC;AAFvB,kEAA2B;AAiBxC;IAAiC,+BAAI;IAGnC,qBAAY,KAAY,EAAU,CAAS;QAA3C,YACE,kBAAM,KAAK,EAAE,SAAS,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,SAClD;QAFiC,OAAC,GAAD,CAAC,CAAQ;;IAE3C,CAAC;IACD,8BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EACzB,6CAA6C,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,EACpB,oDAAoD,CAAC,CAAC;IAC5D,CAAC;IACH,kBAAC;AAAD,CAdA,AAcC,CAdgC,IAAI;AACnB,aAAC,GAAG,GAAG,CAAC;AADb,kCAAW;AAsBxB;IAAyC,uCAAI;IAG3C,6BAAY,KAAY,EAAU,KAAa,EAAU,UAAkB;QAA3E,YACE,kBAAM,KAAK,EAAE,mBAAmB,EAAE,EAAC,KAAK,OAAA,EAAE,UAAU,YAAA,EAAC,EAAE,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC,SACvE;QAFiC,WAAK,GAAL,KAAK,CAAQ;QAAU,gBAAU,GAAV,UAAU,CAAQ;;IAE3E,CAAC;IACD,sCAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EACzD,gDAAgD,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK;YAC/D,iCAAiC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAC5E,CAAC;IACH,0BAAC;AAAD,CAZA,AAYC,CAZwC,IAAI;AAC3B,yBAAK,GAAG,OAAO,CAAC;AAChB,8BAAU,GAAG,YAAY,CAAC;AAF/B,kDAAmB;AAkBhC;IAAgC,8BAAI;IAElC,oBAAY,KAAY,EAAS,CAAS;QAA1C,YACE,kBAAM,KAAK,EAAE,QAAQ,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAC7C;QAFgC,OAAC,GAAD,CAAC,CAAQ;;IAE1C,CAAC;IACD,6BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EACpC,oEAAoE,CAAC,CAAC;IAC5E,CAAC;IACH,iBAAC;AAAD,CAVA,AAUC,CAV+B,IAAI;AAClB,YAAC,GAAG,GAAG,CAAC;AADb,gCAAU;AAgBvB;IAAsC,oCAAI;IAGxC,0BAAY,KAAY,EAAU,EAAU,EAAU,EAAU;QAAhE,YACE,kBAAM,KAAK,EAAE,cAAc,EAAE,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SACxD;QAFiC,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;;IAEhE,CAAC;IACD,mCAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAC9C,0CAA0C,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK;YACtD,yBAAyB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAC5D,CAAC;IACH,uBAAC;AAAD,CAZA,AAYC,CAZqC,IAAI;AACxB,mBAAE,GAAG,IAAI,CAAC;AACV,mBAAE,GAAG,IAAI,CAAC;AAFf,4CAAgB;AAmB7B;IAA+B,6BAAI;IAKjC,mBAAY,KAAY,EAAE,CAAS;QAAnC,YACE,kBAAM,KAAK,EAAE,WAAW,EAAE,EAAC,CAAC,GAAA,EAAC,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,SACpD;QAJD,aAAO,GAAa,EAAE,CAAC;;IAIvB,CAAC;IAMD,sCAAkB,GAAlB;QACE,IAAM,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC1D,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1B,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IACD,4BAAQ,GAAR,cAAY,CAAC;IACf,gBAAC;AAAD,CApBA,AAoBC,CApB8B,IAAI;AACjB,WAAC,GAAG,GAAG,CAAC;AADb,8BAAS;;;;;AC91BtB,+CAAyF;AAOzF;IACE,qBAAoB,CAAQ;QAAR,MAAC,GAAD,CAAC,CAAO;IAAG,CAAC;IAEhC,2BAAK,GAAL,UACI,IAAY,EAAE,CAAS,EAAE,KAAa,EACtC,UAA+C,EAAE,OAAc,EAC/D,iBAAiE,EACjE,eAAqD;QAFrD,2BAAA,EAAA,iBAA+C;QAAE,wBAAA,EAAA,cAAc;QAC/D,kCAAA,EAAA,wBAAqC,yCAA0B,EAAE;QACjE,gCAAA,EAAA,sBAAmC,+BAAgB,EAAE;QACvD,IAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAC3B,IAAI,GAAG,UAAU,EACjB,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAE1E,IAAI,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAEpC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;YACZ,IAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CACxB,IAAI,GAAG,OAAO,EACd,eAAe,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;YAC5D,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,EAAE,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC,CAAC;YACvB,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;QAED,MAAM,CAAC,GAAG,CAAC;IACb,CAAC;IACH,kBAAC;AAAD,CA3BA,AA2BC,IAAA;AA3BY,kCAAW;;;;;ACHxB,0CAA+C;AAE/C,qCAA4D;AAE5D,IAAM,wBAAwB,GAAG,IAAI,CAAC;AACtC,IAAM,wBAAwB,GAAG,GAAG,CAAC;AACrC,IAAM,qCAAqC,GAAG,IAAI,CAAC;AAcnD,IAAY,eAGX;AAHD,WAAY,eAAe;IACzB,mDAAG,CAAA;IACH,qDAAI,CAAA;AACN,CAAC,EAHW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAG1B;AAOD;IAuCE,qBACY,IAAiB,EAAU,OAAgB,EAC3C,aAAuC;QADvC,SAAI,GAAJ,IAAI,CAAa;QAAU,YAAO,GAAP,OAAO,CAAS;QAC3C,kBAAa,GAAb,aAAa,CAA0B;QAX3C,sBAAiB,GAAG,CAAC,CAAC;QACtB,sBAAiB,GAAG,CAAC,CAAC;QAGtB,oBAAe,GAAG,CAAC,CAAC;QAQ1B,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,gBAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,qCAAe,GAAf;QACE,IAAI,CAAC,mBAAmB,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAChC,CAAC;IAOD,2BAAK,GAAL,UACI,UAAkB,EAAE,gBAA6B,EAAE,SAAiB,EACpE,SAAoB,EAAE,UAAmB,EAAE,YAAqB,EAChE,iBAA+B,EAAE,eAAwB,EACzD,eAAsC,EACtC,cAAyC,EACzC,cAAyC;QAFzC,gCAAA,EAAA,kBAAkB,eAAe,CAAC,IAAI;QACtC,+BAAA,EAAA,yCAAyC;QACzC,+BAAA,EAAA,yCAAyC;QAC3C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,EAAE,CAAC,CAAC,eAAe,IAAI,IAAI,IAAI,IAAI,CAAC,eAAe,KAAK,eAAe,CAAC,CAAC,CAAC;YACxE,EAAE,CAAC,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,CAAC,CAAC;gBACvC,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,CAAC;YACvC,CAAC;YACD,IAAI,CAAC,qBAAqB,GAAG,gBAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAE3B,IAAI,CAAC,gBAAgB,GAAG,cAAc,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,0BAA0B,GAAG,UAAU,CAAC;QAE7C,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7C,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,kCAAY,GAAZ;QACE,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAC7C,CAAC;IAED,oCAAc,GAAd;QACE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,CAAC,CAAC;YACnC,IAAI,CAAC,eAAe,IAAI,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAEO,kCAAY,GAApB;QAAA,iBAgEC;QA/DC,EAAE,CAAC,CAAC,IAAI,CAAC,qBAAqB,KAAK,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;QAED,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YACrB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,oBAAoB,IAAI,IAAI,CAAC,CAAC,CAAC;gBACpD,IAAI,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;YAC5C,CAAC;YACD,MAAM,CAAC;QACT,CAAC;QAED,IAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,IAAM,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,IAAI,IAAI;YAChE,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3D,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;YACtB,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QACjC,CAAC;QAED,IAAM,aAAa,GACf,iBAAiB,GAAG,uBAAa,CAAC,IAAI,GAAG,uBAAa,CAAC,IAAI,CAAC;QAEhE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACnB,IAAM,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,KAAK,CAC9B,KAAI,CAAC,UAAU,EAAE,KAAI,CAAC,gBAAgB,EAAE,KAAI,CAAC,SAAS,EACtD,KAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAEnC,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBACtB,IAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBAE5C,KAAI,CAAC,aAAa,CAAC,eAAgB,CAAC,OAAO,CAAC,CAAC;gBAE7C,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,2BAA2B,IAAI,IAAI,CAAC,CAAC,CAAC;oBAC3D,IAAM,cAAc,GAAG,CAAC,KAAI,CAAC,SAAS,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;oBAC3D,KAAI,CAAC,aAAa,CAAC,2BAA2B,CAAC,cAAc,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,cAAc,IAAI,IAAI;gBACzC,KAAI,CAAC,iBAAiB,IAAI,IAAI;gBAC9B,KAAK,GAAG,KAAI,CAAC,iBAAiB,GAAG,KAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBAC3D,KAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;gBAE/B,EAAE,CAAC,CAAC,KAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC;oBACpC,KAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC;gBACpC,CAAC;gBACD,KAAI,CAAC,kBAAkB,GAAG,KAAI,CAAC,aAAa,EAAE,CAAC;gBAC/C,KAAI,CAAC,aAAa,CAAC,cAAc,CAAC,KAAI,CAAC,kBAAkB,CAAC,CAAC;YAC7D,CAAC;YAED,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,iBAAiB,IAAI,IAAI,CAAC,CAAC,CAAC;gBACjD,KAAI,CAAC,aAAa,CAAC,iBAAiB,CAChC,CAAC,KAAK,GAAG,KAAI,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,CAAC;YACjD,CAAC;YAED,KAAI,CAAC,qBAAqB,EAAE,CAAC;YAC7B,KAAI,CAAC,mBAAmB,EAAE,CAAC;YAE3B,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,sBAAsB,IAAI,IAAI,CAAC,CAAC,CAAC;gBACtD,KAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,KAAI,CAAC,mBAAmB,CAAC,CAAC;YACtE,CAAC;QAEH,CAAC,CAAC,CAAC;QACH,UAAU,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,EAAE,EAAnB,CAAmB,CAAC,CAAC;IACxC,CAAC;IAED,2BAAK,GAAL,UACI,eAAuB,EAAE,oBAAiC,EAC1D,0BAAkE,EAClE,qBAAyB,EAAE,SAAkB;QAHjD,iBAgCC;QA9BG,2CAAA,EAAA,kEAAkE;QAClE,sCAAA,EAAA,yBAAyB;QAC3B,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,yBAAyB,IAAI,IAAI;YACpD,IAAI,CAAC,aAAa,CAAC,+BAA+B,IAAI,IAAI,CAAC,CAAC,CAAC;YAC/D,MAAM,IAAI,KAAK,CACX,uDAAuD;gBACvD,iCAAiC,CAAC,CAAC;QACzC,CAAC;QAGD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrD,IAAM,SAAS,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;YAE1C,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,YAAY,iBAAO,CAAC,CAAC,CAAC;gBACtC,MAAM,IAAI,KAAK,CACX,kEAAkE;oBAClE,0CAA0C,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;QAC7D,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;QACjD,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QACnD,IAAI,CAAC,6BAA6B,GAAG,SAAS,CAAC;QAC/C,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YACtB,IAAI,CAAC,sBAAsB,GAAG,CAAC,CAAC;YAChC,UAAU,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,EAAE,EAAnB,CAAmB,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAEO,kCAAY,GAApB;QAAA,iBAgDC;QA/CC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW;YACjB,IAAI,CAAC,sBAAsB,KAAK,IAAI,CAAC,6BAA6B,CAAC,CAAC,CAAC;YACvE,MAAM,CAAC;QACT,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI,EAAE,KAAK;YAC1B,IAAM,KAAK,GAAkB,EAAE,CAAC;YAChC,IAAM,eAAe,GAAc,EAAE,CAAC;YAEtC,IAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YAChC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAI,CAAC,qBAAqB,EAAE,CAAC,EAAE,EAAE,CAAC;gBAEpD,IAAM,kBAAkB,GAAgB,EAAE,CAAC;gBAC3C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAI,CAAC,oBAAqB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC3D,IAAM,SAAS,GAAG,KAAI,CAAC,oBAAqB,CAAC,CAAC,CAAC,CAAC;oBAChD,kBAAkB,CAAC,IAAI,CAAC;wBACtB,MAAM,EAAE,SAAS,CAAC,MAAM;wBACxB,IAAI,EACA,KAAK,CAAE,SAAS,CAAC,IAAsB,CAAC,WAAW,CAAC,KAAI,CAAC,IAAI,CAAC,CAAC;qBACpE,CAAC,CAAC;gBACL,CAAC;gBACD,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;gBAE/B,eAAe,CAAC,IAAI,CAChB,KAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAI,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC,CAAC;YACnE,CAAC;YAED,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,+BAA+B,IAAI,IAAI,CAAC,CAAC,CAAC;gBAI/D,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;gBAExD,IAAM,2BAA2B,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBAE9D,IAAM,cAAc,GAChB,CAAC,KAAI,CAAC,qBAAqB,GAAG,IAAI,GAAG,2BAA2B,CAAC,CAAC;gBACtE,KAAI,CAAC,aAAa,CAAC,+BAAgC,CAAC,cAAc,CAAC,CAAC;YACtE,CAAC;YAED,EAAE,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,yBAAyB,IAAI,IAAI,CAAC,CAAC,CAAC;gBACzD,KAAI,CAAC,aAAa,CAAC,yBAAyB,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;YACvE,CAAC;YACD,KAAI,CAAC,sBAAsB,EAAE,CAAC;QAEhC,CAAC,CAAC,CAAC;QACH,UAAU,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,EAAE,EAAnB,CAAmB,EAAE,IAAI,CAAC,0BAA0B,CAAC,CAAC;IACzE,CAAC;IAED,mCAAa,GAAb;QACE,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,wCAAkB,GAAlB;QACE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,mCAAa,GAAb;QAAA,iBAqBC;QApBC,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,CAAC,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;QAE7B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YAC1B,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAI,CAAC,eAAgB,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/C,IAAM,WAAW,GACb,KAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAI,CAAC,YAAa,EAAE,KAAI,CAAC,iBAAkB,CAAC,CAAC;gBAEnE,MAAM,GAAG,KAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAC9C,CAAC;YAED,EAAE,CAAC,CAAC,KAAI,CAAC,eAAe,KAAK,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;gBAClD,MAAM,GAAG,KAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,KAAI,CAAC,qBAAqB,CAAC,CAAC;YAChE,CAAC;YAED,MAAM,CAAC,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,4CAAsB,GAAtB;QACE,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,2CAAqB,GAArB;QACE,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,6BAAO,GAAP,UAAQ,IAAiB;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,gCAAU,GAAV,UAAW,OAAgB;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,wCAAkB,GAAlB,UAAmB,eAAuB;QACxC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;IAED,8CAAwB,GAAxB,UAAyB,qBAA6B;QACpD,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;IACrD,CAAC;IACH,kBAAC;AAAD,CAlTA,AAkTC,IAAA;AAlTY,kCAAW;;;;;ACnCxB,iCAAyF;AACzF,iDAAmD;AACnD,mDAA+C;AAW/C,mCACI,KAAa,EAAE,gBAAwB;IACzC,IAAM,kBAAkB,GAAyB,EAAE,CAAC;IACpD,IAAM,IAAI,GAAyB,EAAE,CAAC;IACtC,IAAM,GAAG,GAAW,EAAE,CAAC;IACvB,IAAM,KAAK,GAAW,KAAK,CAAC,KAAK,EAAE,CAAC;IACpC,gBAAgB,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAlC,CAAkC,CAAC,CAAC;;QAKnE,IAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QACzB,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,EAAE,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;gBACvC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;qBAClB,GAAG,CAAC,UAAA,SAAS,IAAI,OAAA,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,EAArB,CAAqB,CAAC;qBACvC,OAAO,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAtB,CAAsB,CAAC,CAAC;YAChD,CAAC;YACD,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACd,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QACrB,CAAC;IACH,CAAC;IAXD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;;KAWxB;IACD,MAAM,CAAC,GAAG,CAAC;AACb,CAAC;AAvBD,8DAuBC;AAUD,iCAAwC,sBAA8B;IAKpE,IAAM,GAAG,GAAW,EAAE,CAAC;IACvB,IAAM,WAAW,GAA2B,EAAE,CAAC;IAC/C,IAAM,mBAAmB,GAA2B,EAAE,CAAC;IAKvD,IAAM,SAAS,GAAG,IAAI,8BAAa,CAC/B,UAAC,CAAO,EAAE,CAAO,IAAK,OAAA,cAAc,CAAC,cAAc,CAC/C,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EADnC,CACmC,EACzD,UAAC,IAAU,EAAE,QAAgB,IAAK,OAAA,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,EAA/B,CAA+B,CAAC,CAAC;IAEvE,sBAAsB,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAhC,CAAgC,CAAC,CAAC;IAKzE,sBAAsB,CAAC,OAAO,CAC1B,UAAA,IAAI,IAAI,OAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;SACnB,GAAG,CAAC,UAAA,GAAG,IAAI,OAAA,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAhB,CAAgB,CAAC;SAC5B,OAAO,CAAC,UAAA,KAAK;QACZ,EAAE,CAAC,CAAC,sBAAsB,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACtD,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;QACvC,CAAC;IACH,CAAC,CAAC,EANN,CAMM,CAAC,CAAC;IAEpB,sBAAsB,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAvB,CAAuB,CAAC,CAAC;IAEhE,OAAO,CAAC,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC;QAC1B,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;QAIjC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAlB,CAAkB,CAAC,CAAC,OAAO,CAAC,UAAA,KAAK;YACrE,EAAE,CAAC,CAAC,sBAAsB,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtD,MAAM,CAAC;YACT,CAAC;YACD,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YACrC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,GAAG,CAAC;AACb,CAAC;AAhDD,0DAgDC;AAKD,qBAA4B,IAAU;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AAC/C,CAAC;AAFD,kCAEC;AAED,wBAA+B,CAAS;IACtC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,YAAY,oBAAY,CAAC,CAAC;AAC3C,CAAC;AAFD,wCAEC;AAED,2BAAkC,IAAU,EAAE,GAAmB;IAC/D,IAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACxD,MAAM,CAAC,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,MAAM,CAAC,KAAK,CAAC;AACf,CAAC;AATD,8CASC;;;;;ACpHD,4CAA8C;AAqBtC,8BAAS;AApBjB,oDAAsD;AAoBnC,gCAAU;AAnB7B,8EAAgF;AAmBjD,0DAAuB;AAlBtD,oDAAsD;AAkBQ,gCAAU;AAjBxE,6BAA+B;AAiByB,oBAAI;AAf5D,yDAAqD;AAA7C,+CAAA,gBAAgB,CAAA;AACxB,qCAAqD;AAAlC,oCAAA,eAAe,CAAA;AAClC,iCAAsC;AAA9B,wBAAA,KAAK,CAAA;AAAE,yBAAA,MAAM,CAAA;AACrB,+CAAsF;AAA9E,qCAAA,WAAW,CAAA;AAA4B,yCAAA,eAAe,CAAA;AAC9D,+CAAwO;AAAhO,6CAAA,mBAAmB,CAAA;AAAe,4CAAA,kBAAkB,CAAA;AAAE,yCAAA,eAAe,CAAA;AAAE,iDAAA,uBAAuB,CAAA;AAAE,0DAAA,gCAAgC,CAAA;AAAE,kDAAA,wBAAwB,CAAA;AAAE,oDAAA,0BAA0B,CAAA;AAAE,0CAAA,gBAAgB,CAAA;AAChN,mDAAiI;AAAzH,mEAAA,uCAAuC,CAAA;AAAE,mEAAA,uCAAuC,CAAA;AACxF,oCAA2D;AAAnD,mCAAA,iBAAiB,CAAA;AAAE,6BAAA,WAAW,CAAA;AACtC,4CAA+C;AAAvC,oCAAA,cAAc,CAAA;AACtB,4CAA+C;AAAvC,oCAAA,cAAc,CAAA;AACtB,0CAAmF;AAA3E,4BAAA,OAAO,CAAA;AAAE,4BAAA,OAAO,CAAA;AAAE,4BAAA,OAAO,CAAA;AAAE,4BAAA,OAAO,CAAA;AAAE,4BAAA,OAAO,CAAA;AAAE,2BAAA,MAAM,CAAA;AAC3D,4DAAwD;AAAhD,uCAAA,YAAY,CAAA;AACpB,yCAAsC;AAA9B,gCAAA,SAAS,CAAA;AACjB,qCAA4D;AAApD,kCAAA,aAAa,CAAA;AAAa,4BAAA,OAAO,CAAA;AACzC,iDAA6C;AAArC,uCAAA,YAAY,CAAA;;;;;ACnBpB,0CAAuC;AAUvC;IACE,oCACY,KAAW,EACX,IAA6C,EAC7C,YAA2C;QAF3C,sBAAA,EAAA,WAAW;QACX,qBAAA,EAAA,eAA6C;QAC7C,6BAAA,EAAA,uBAA2C;QAF3C,UAAK,GAAL,KAAK,CAAM;QACX,SAAI,GAAJ,IAAI,CAAyC;QAC7C,iBAAY,GAAZ,YAAY,CAA+B;IAAG,CAAC;IAE3D,+CAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC;YAC3B,CAAC,GAAG,UAAU,CAAC;QACjB,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACnC,CAAC,GAAG,WAAW,CAAC;QAClB,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACnC,CAAC,GAAG,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,MAAM,IAAI,KAAK,CACX,oDAAoD,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QACxE,CAAC;QAED,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC;YACnC,MAAM,CAAC,iBAAO,CAAC,mBAAmB,CAC9B,YAAY,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QACpD,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC;YAC3C,MAAM,CAAC,iBAAO,CAAC,WAAW,CACtB,YAAY,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,MAAM,IAAI,KAAK,CACX,4DAA4D;gBAC5D,IAAI,CAAC,YAAY,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IACH,iCAAC;AAAD,CAhCA,AAgCC,IAAA;AAhCY,gEAA0B;AAkCvC;IACE;IAAe,CAAC;IAEhB,qCAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,MAAM,CAAC,iBAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IACH,uBAAC;AAAD,CAPA,AAOC,IAAA;AAPY,4CAAgB;AAS7B;IACE;IAAe,CAAC;IAEhB,oCAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,IAAM,MAAM,GAAG,iBAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IACH,sBAAC;AAAD,CATA,AASC,IAAA;AATY,0CAAe;AAW5B;IACE,6BAAoB,KAAS;QAAT,sBAAA,EAAA,SAAS;QAAT,UAAK,GAAL,KAAK,CAAI;IAAG,CAAC;IAEjC,wCAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,IAAM,MAAM,GAAG,iBAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IACH,0BAAC;AAAD,CATA,AASC,IAAA;AATY,kDAAmB;AAWhC;IACE,4BAAoB,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;IAAG,CAAC;IAExC,uCAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACH,yBAAC;AAAD,CAPA,AAOC,IAAA;AAPY,gDAAkB;AAS/B;IACE,iCAAoB,IAAQ,EAAU,KAAW;QAA7B,qBAAA,EAAA,QAAQ;QAAU,sBAAA,EAAA,WAAW;QAA7B,SAAI,GAAJ,IAAI,CAAI;QAAU,UAAK,GAAL,KAAK,CAAM;IAAG,CAAC;IAErD,4CAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,MAAM,CAAC,iBAAO,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACjE,CAAC;IACH,8BAAC;AAAD,CAPA,AAOC,IAAA;AAPY,0DAAuB;AASpC;IACE,0CAAoB,IAAQ,EAAU,KAAW;QAA7B,qBAAA,EAAA,QAAQ;QAAU,sBAAA,EAAA,WAAW;QAA7B,SAAI,GAAJ,IAAI,CAAI;QAAU,UAAK,GAAL,KAAK,CAAM;IAAG,CAAC;IAErD,qDAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,MAAM,CAAC,iBAAO,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1E,CAAC;IACH,uCAAC;AAAD,CAPA,AAOC,IAAA;AAPY,4EAAgC;AAS7C;IACE,kCAAoB,MAAa,EAAU,MAAY;QAAnC,uBAAA,EAAA,UAAU,GAAG;QAAU,uBAAA,EAAA,YAAY;QAAnC,WAAM,GAAN,MAAM,CAAO;QAAU,WAAM,GAAN,MAAM,CAAM;IAAG,CAAC;IAE3D,6CAAU,GAAV,UAAW,YAAsB,EAAE,UAAkB,EAAE,WAAmB;QAExE,MAAM,CAAC,iBAAO,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACrE,CAAC;IACH,+BAAC;AAAD,CAPA,AAOC,IAAA;AAPY,4DAAwB;;;;;;;;;;;;;;;ACrGrC,0CAAuC;AACvC,6BAA+B;AAgC/B;IAiBE,8CAAsB,MAAmB;QAAnB,WAAM,GAAN,MAAM,CAAa;QAZ/B,QAAG,GAAG,CAAC,CAAC;QAGR,iBAAY,GAAG,CAAC,CAAC;QACjB,UAAK,GAAG,CAAC,CAAC;QASlB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACpE,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;QAG/B,IAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC1C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,EACrC,wDAAwD,CAAC,CAAC;QAChE,CAAC;QAGD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,IAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAC3C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/C,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;IACH,CAAC;IAES,qEAAsB,GAAhC;QACE,IAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC;QAE3B,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,GAAG,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;YAEtB,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;gBACtC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;gBACb,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;QACH,CAAC;QACD,MAAM,CAAC,SAAS,CAAC;IACnB,CAAC;IAES,2DAAY,GAAtB,UAAuB,OAAe;QACpC,IAAM,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE1D,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACzE,CAAC;IAED,uDAAQ,GAAR;QACE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAKD,gEAAiB,GAAjB;QACE,IAAM,cAAc,GAAoB,EAAE,CAAC;QAE3C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,CAAC;QACD,MAAM,CAAC,cAAc,CAAC;IACxB,CAAC;IAGH,2CAAC;AAAD,CA7EA,AA6EC,IAAA;AA7EqB,oFAAoC;AAmF1D;IACI,2DAAoC;IADxC;;IAcA,CAAC;IAZC,kEAAgB,GAAhB,UAAiB,OAAe;QAC9B,IAAM,qBAAqB,GAAG,IAAI,CAAC;QAEnC,MAAM,CAAC;YACL,WAAW,EAAX,UAAY,IAAiB;gBAC3B,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;YACnE,CAAC;YACD,WAAW,YAAC,IAAiB,EAAE,IAAa;gBAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC;SACF,CAAC;IACJ,CAAC;IACH,8CAAC;AAAD,CAdA,AAcC,CAbG,oCAAoC,GAavC;AAdY,0FAAuC;AAsBpD;IACI,2DAAoC;IADxC;;IAcA,CAAC;IAZC,kEAAgB,GAAhB,UAAiB,OAAe;QAC9B,IAAM,qBAAqB,GAAG,IAAI,CAAC;QAEnC,MAAM,CAAC;YACL,WAAW,EAAX,UAAY,IAAiB;gBAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;YACjE,CAAC;YACD,WAAW,YAAC,IAAiB,EAAE,IAAa;gBAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC;SACF,CAAC;IACJ,CAAC;IACH,8CAAC;AAAD,CAdA,AAcC,CAbG,oCAAoC,GAavC;AAdY,0FAAuC;;;;;AC1IpD,qCAA0C;AAQ1C;IAAA;IAcA,CAAC;IAbC,yBAAM,GAAN,UAAO,IAAiB,EAAE,CAAU;QAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAG,GAAH,UAAI,IAAiB,EAAE,CAAU,EAAE,CAAU;QAC3C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,IAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAE3C,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,gBAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC;IACH,eAAC;AAAD,CAdA,AAcC,IAAA;AAdY,4BAAQ;AAgBrB;IAAA;IAYA,CAAC;IAXC,yBAAM,GAAN,UAAO,IAAiB,EAAE,CAAU;QAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAG,GAAH,UAAI,IAAiB,EAAE,CAAU,EAAE,CAAU;QAC3C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IACH,eAAC;AAAD,CAZA,AAYC,IAAA;AAZY,4BAAQ;AAcrB;IAAA;IAcA,CAAC;IAbC,4BAAM,GAAN,UAAO,IAAiB,EAAE,CAAU;QAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yBAAG,GAAH,UAAI,IAAiB,EAAE,CAAU,EAAE,CAAU;QAC3C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAEhB,IAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;IACH,kBAAC;AAAD,CAdA,AAcC,IAAA;AAdY,kCAAW;AAgBxB;IAAA;IAaA,CAAC;IAZC,2BAAM,GAAN,UAAO,IAAiB,EAAE,CAAU;QAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wBAAG,GAAH,UAAI,IAAiB,EAAE,CAAU,EAAE,CAAU;QAC3C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAEhB,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,gBAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC;IACH,iBAAC;AAAD,CAbA,AAaC,IAAA;AAbY,gCAAU;;;;;ACvDvB,8BAAgC;AAEhC,mCACI,OAAiB,EAAE,OAAiB,EAAE,IAAY,EAClD,kBAAuB;IAAvB,mCAAA,EAAA,uBAAuB;IACzB,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,MAAM,KAAK,CAAC,EACpB,kBAAkB,GAAG,wCAAwC,CAAC,CAAC;IACnE,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,MAAM,KAAK,CAAC,EACpB,kBAAkB,GAAG,wCAAwC,CAAC,CAAC;IAEnE,IAAI,CAAC,MAAM,CACP,IAAI,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,4CAA4C,CAAC,CAAC;IAEzE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,EAC3C,kBAAkB;aACd,YAAU,OAAO,0BAAqB,OAAO,aAAU,CAAA;YACvD,wBAAwB,CAAC,CAAC;IACpC,CAAC;AACH,CAAC;AApBD,8DAoBC;AAED,oCACI,OAAiB,EAAE,OAAiB,EACpC,IAAY;IACd,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,wCAAwC,CAAC,CAAC;IAC5E,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,uCAAuC,CAAC,CAAC;IAE3E,IAAM,WAAW,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IACpC,WAAW,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,CAAC,WAAuC,CAAC;AACjD,CAAC;AATD,gEASC;;;;;ACjCD,8BAAgC;AAEhC,8BACI,qBAA+C,EAAE,SAAiB,EAClE,KAAa,EAAE,MAAc,EAAE,OAAgB;IACjD,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;QACpB,OAAO,GAAG,iBAAiB,CAAC,qBAAqB,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACxE,CAAC;IACD,IAAM,SAAS,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAM,SAAS,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAM,UAAU,GAAG,CAAC,SAAS,GAAG,SAAS,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IACtE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,EACtB,2BAAyB,UAAU,sCAAmC;QAClE,mCAAmC,CAAC,CAAC;IAE7C,IAAM,UAAU,GAAG,CAAC,SAAS,GAAG,SAAS,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IACtE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,EACtB,8BAA4B,UAAU,kCAA+B;QACjE,uCAAuC,CAAC,CAAC;IAEjD,MAAM,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AArBD,oDAqBC;AAED,2BACI,UAAoC,EAAE,SAAiB,EACvD,MAAc;IAChB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7E,CAAC;AAJD,8CAIC;AAED,+BACI,gBAA0C;IAC5C,MAAM,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1E,CAAC;AAHD,sDAGC;AAED,+BACI,UAAkB,EAAE,WAAmB,EACvC,KAAa;IACf,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;AACjD,CAAC;AAJD,sDAIC;AAED,gCACI,UAAkB,EAAE,WAAmB,EACvC,SAAiB;IACnB,MAAM,CAAC,CAAC,SAAS,GAAG,SAAS,GAAG,UAAU,EAAE,WAAW,CAAC,CAAC;AAC3D,CAAC;AAJD,wDAIC;AAED,+BAAsC,WAAmB;IACvD,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;AAC1B,CAAC;AAFD,sDAEC;AAED,0BACI,EAAoB,EAAE,UAAkB;IAC1C,IAAM,WAAW,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;IACjD,IAAM,WAAW,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;IACjD,MAAM,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AACpC,CAAC;AALD,4CAKC;;;;;ACzDD,wBACI,UAA4B,EAAE,QAA0B;IAC1D,IAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC1C,EAAE,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC;QACxB,IAAM,MAAM,GAAG,GAAG,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAChE,IAAM,MAAM,GAAG,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAC5D,MAAM,IAAI,KAAK,CACX,oDAAoD,GAAG,MAAM;YAC7D,SAAS,GAAG,OAAO,GAAG,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC;AAXD,wCAWC;;;;;ACVD,qCAA0C;AAW1C;IAAA;QACU,YAAO,GAAG,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAoBpC,CAAC;IAlBC,6BAAI,GAAJ,UAAK,IAAiB,EAAE,EAAW,EAAE,EAAW;QAC9C,IAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9B,IAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAEhE,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,WAAW,CAAC,OAAO,EAAE,CAAC;QAEtB,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAED,4BAAG,GAAH,UAAI,IAAiB,EAAE,EAAW,EAAE,EAAW;QAC7C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,gCAAO,GAAP;QACE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;IACH,qBAAC;AAAD,CArBA,AAqBC,IAAA;AArBY,wCAAc;;;;;ACZ3B,8BAAgC;AAChC,+CAAiD;AACjD,2CAA6C;AAE7C,qCAA8E;AAI9E;IAWE,qBAAoB,QAAiB;QAAjB,aAAQ,GAAR,QAAQ,CAAS;QAV7B,kBAAa,GAAgB,EAAE,CAAC;QAGhC,mBAAc,GAAgB,EAAE,CAAC;QACjC,8BAAyB,GAAc,EAAE,CAAC;IAMV,CAAC;IAUzC,2BAAK,GAAL,UACI,OAEyD;QAH7D,iBAaC;QATC,IAAI,CAAC,UAAU,EAAE,CAAC;QAElB,IAAM,MAAM,GAAG,UAAoB,OAAU,IAAQ,OAAA,KAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAlB,CAAkB,CAAC;QACxE,IAAM,OAAO,GAAG,UAAoB,OAAU,IAAQ,OAAA,KAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAnB,CAAmB,CAAC;QAC1E,IAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAExC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEtB,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAMD,gCAAU,GAAV;QACE,IAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAE5B,IAAM,iBAAiB,GAAc,EAAE,CAAC;QACxC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC5C,IAAI,CAAC,yBAAyB,GAAG,iBAAiB,CAAC;IACrD,CAAC;IAMD,8BAAQ,GAAR,UAAS,MAAmB;QAA5B,iBAoCC;QAlCC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,IAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAEpC,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,yBAAyB,CAAC;gBACjE,CAAC,MAAM,IAAI,IAAI,IAAI,MAAM,YAAY,iBAAO;oBAC3C,OAAO,CAAC,OAAO,EAAE,KAAM,MAAkB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC1D,QAAQ,CAAC;YACX,CAAC;YACD,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QAGD,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC;YAC9C,IAAK;YACL,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAGtD,EAAE,CAAC,CAAC,MAAM,YAAY,iBAAO;YACzB,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrB,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACjC,MAAM,CAAC,OAAO,CAAC,UAAA,CAAC;gBACd,EAAE,CAAC,CAAC,CAAC,YAAY,iBAAO;oBACpB,CAAC,KAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,KAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC;oBACjE,KAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC;YAC7D,IAAK;YACL,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC1D,CAAC;IAEO,yCAAmB,GAA3B,UAA4B,OAAgB,EAAE,WAAsB;QAClE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBACnD,MAAM,CAAC,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,MAAM,CAAC,KAAK,CAAC;IACf,CAAC;IAMD,0BAAI,GAAJ,UAAwB,MAAS;QAC/B,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC,CAAC;YAC7B,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAClB,MAAM,IAAI,KAAK,CACX,+CAA+C;oBAC/C,sCAAsC;oBACtC,wDAAwD;oBACxD,QAAQ,CAAC,CAAC;YAChB,CAAC;YACD,MAAM,CAAC,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAOD,2BAAK,GAAL,UAAyB,MAAS;QAChC,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC,CAAC;YAC7B,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAClB,MAAM,IAAI,KAAK,CACX,+CAA+C;oBAC/C,sCAAsC;oBACtC,wDAAwD;oBACxD,QAAQ,CAAC,CAAC;YAChB,CAAC;YACD,MAAM,CAAC,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAaD,4BAAM,GAAN,UACI,CAAU,EAAE,CAAU,EAAE,YAAwC,EAChE,YAAwC;QADhB,6BAAA,EAAA,eAAe,iBAAiB,CAAC,OAAO;QAChE,6BAAA,EAAA,eAAe,iBAAiB,CAAC,OAAO;QAC1C,IAAM,WAAW,GACb,CAAC,YAAY,KAAK,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAM,WAAW,GACb,CAAC,YAAY,KAAK,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE3E,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,EAC5B,uDAAqD,CAAC,CAAC,IAAM;aACzD,SAAO,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAE1B,IAAI,CAAC,MAAM,CACP,WAAW,KAAK,WAAW,EAC3B,oCAAkC,WAAW,YAAS;aAC/C,WAAW,kCAA6B,CAAC,CAAC,KAAK,UAAO,CAAA;aACtD,CAAC,CAAC,KAAK,0BAAqB,iBAAiB,CAAC,YAAY,CAAG,CAAA;aAChE,UAAQ,iBAAiB,CAAC,YAAY,CAAC,iBAAc,CAAA,CAAC,CAAC;QAE/D,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;IAC3E,CAAC;IAUD,uCAAiB,GAAjB,UAAkB,CAAU,EAAE,MAAe;QAC3C,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,kEAAkE;aAC9D,UAAQ,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3B,IAAI,CAAC,MAAM,CACP,MAAM,CAAC,IAAI,KAAK,CAAC,EACjB,mEAAmE;aAC/D,UAAQ,MAAM,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAC1B,6DAA2D,CAAC,CAAC,IAAI,OAAI;YACjE,6DAA6D;aAC7D,UAAQ,MAAM,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAEhC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;IACvD,CAAC;IAOD,uCAAiB,GAAjB,UAAkB,MAAe,EAAE,CAAU;QAC3C,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,gEAAgE;aAC5D,UAAQ,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3B,IAAI,CAAC,MAAM,CACP,MAAM,CAAC,IAAI,KAAK,CAAC,EACjB,oEAAoE;aAChE,UAAQ,MAAM,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAC1B,4DAA0D,CAAC,CAAC,IAAI,MAAG;YAC/D,6DAA6D;aAC7D,WAAS,MAAM,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QAElC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACvD,CAAC;IAOD,gCAAU,GAAV,UAAW,EAAW,EAAE,EAAW;QACjC,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,CAAC,EAC9B,4DAA4D;aACrD,EAAE,CAAC,IAAI,aAAQ,EAAE,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,EACnB,0CAAwC,EAAE,CAAC,IAAI,YAAS;aACjD,EAAE,CAAC,IAAI,kBAAe,CAAA,CAAC,CAAC;QACnC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1E,CAAC;IAOD,kCAAY,GAAZ,UAAa,EAAW,EAAE,EAAW;QACnC,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,CAAC,EAC9B,8DAA8D;aACvD,EAAE,CAAC,IAAI,aAAQ,EAAE,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAEtC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/D,CAAC;IAUD,2BAAK,GAAL,UAAyB,OAAU;QACjC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,CAAC;IAUD,6BAAO,GAAP,UACI,OAAW,EAAE,QAAkB;QACjC,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAC7C,gCAA8B,OAAO,CAAC,IAAI,0BAAuB;aAC1D,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAG,CAAA,CAAC,CAAC;QAC5C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAS,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;IACrE,CAAC;IAYD,6BAAO,GAAP,UAAQ,KAAc,EAAE,KAAuB,EAAE,IAAsB;QAErE,IAAI,CAAC,MAAM,CACP,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAChC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACxC,gDAA8C,KAAK,eAAY;aACxD,IAAI,uCAAkC,KAAK,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QACjE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IAC9D,CAAC;IAeD,4BAAM,GAAN,UACI,MAAe,EAAE,WAA6B,EAC9C,UAA4B,EAAE,IAAa,EAAE,SAA2B,EACxE,QAA0B;QAC5B,IAAI,CAAC,MAAM,CACP,WAAW,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7C,WAAW,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EACrD,sDAAoD,WAAW,MAAG;aAC9D,qBAAmB,UAAU,mCAAgC,CAAA;aAC7D,cAAY,MAAM,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,CACP,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YACvC,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAC/C,oDAAkD,SAAS,MAAG;aAC1D,qBAAmB,QAAQ,oCAAiC,CAAA;aAC5D,WAAS,IAAI,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QAChC,WAAW,CAAC,cAAc,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAEjD,MAAM,CAAC,IAAI,CAAC,cAAc,CACtB,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAClE,CAAC;IAoCD,8BAAQ,GAAR,UAAS,QAAiB,EAAE,QAAiB,EAAE,IAAY;QACzD,aAAa,CAAC,yBAAyB,CACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,qBAAqB,CAAC,CAAC;QACjE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;IACrE,CAAC;IAYD,+BAAS,GAAT,UAAU,OAAgB;QACxB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,CAAC;IAOD,yBAAG,GAAH,UAAI,OAAgB;QAClB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAOD,4BAAM,GAAN,UAAO,OAAgB;QACrB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,CAAC;IAOD,4BAAM,GAAN,UAAO,OAAgB;QACrB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,CAAC;IAQD,kCAAY,GAAZ,UAAa,EAAW,EAAE,EAAW;QACnC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,yBAAyB,CAAC,CAAC;QACtE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACvD,CAAC;IAQD,0BAAI,GAAJ,UAAK,OAAgB,EAAE,CAAS;QAC9B,IAAI,CAAC,MAAM,CACP,CAAC,IAAI,OAAO,CAAC,IAAI,EACjB,6BAA2B,CAAC,uCAAoC;aAC5D,wBAAsB,OAAO,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QAChD,IAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC3B,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAQD,yBAAG,GAAH,UAAI,OAAgB;QAClB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAOD,yBAAG,GAAH,UAAI,OAAgB;QAClB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAOD,6BAAO,GAAP,UAAQ,CAAU;QAAlB,iBAQC;QAPC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAGhB,IAAM,GAAG,GAAG,KAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAM,SAAS,GAAG,KAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YAChD,MAAM,CAAC,KAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;IAWD,+BAAS,GAAT,UAA6B,CAAI,EAAE,MAAgB;QACjD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,MAAM,EACxB,+CAA6C,CAAC,CAAC,KAAK,MAAG;aACnD,qCAAmC,MAAM,MAAG,CAAA,CAAC,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,CAAC;IASD,qCAAe,GAAf,UAAmC,CAAS,EAAE,CAAI;QAChD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,mEAAmE;aAC/D,UAAQ,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACxD,CAAC;IASD,sCAAgB,GAAhB,UAAoC,CAAS,EAAE,CAAI;QACjD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,oEAAoE;aAChE,UAAQ,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IASD,sCAAgB,GAAhB,UAAoC,CAAI,EAAE,CAAS;QACjD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,iEAAiE;aAC7D,cAAY,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IAQD,yBAAG,GAAH,UAAuB,CAAI;QACzB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAQD,yBAAG,GAAH,UAAuB,CAAI,EAAE,CAAI;QAC/B,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;QAC3D,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAQD,yBAAG,GAAH,UAAuB,CAAI,EAAE,CAAI;QAC/B,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;QAC3D,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IASD,oCAAc,GAAd,UAAkC,CAAI,EAAE,CAAI;QAC1C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAC;QACtE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACvD,CAAC;IASD,4BAAM,GAAN,UAA0B,CAAI,EAAE,CAAI;QAClC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IASD,0CAAoB,GAApB,UAAwC,CAAS,EAAE,CAAI;QACrD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,oEAAoE;aAChE,yBAAuB,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7D,CAAC;IAUD,0CAAoB,GAApB,UAAwC,CAAI,EAAE,CAAS;QACrD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,iEAAiE;aAC7D,6BAA2B,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC9C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7D,CAAC;IAQD,yBAAG,GAAH,UAAuB,OAAU;QAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAOD,yBAAG,GAAH,UAAuB,OAAU;QAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAOD,0BAAI,GAAJ,UAAwB,OAAU;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAChD,CAAC;IAOD,6BAAO,GAAP,UAA2B,OAAU;QACnC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,CAAC;IAOD,0BAAI,GAAJ,UAAwB,OAAU;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAChD,CAAC;IAOD,yBAAG,GAAH,UAAuB,OAAU;QAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/C,CAAC;IAQD,0BAAI,GAAJ,UAAwB,OAAU;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAChD,CAAC;IAUD,oCAAc,GAAd,UAAkC,EAAU,EAAE,CAAI,EAAE,EAAU,EAAE,CAAI;QAClE,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,EACb,+DAA+D;aAC3D,WAAS,EAAE,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,EACb,kEAAkE;aAC9D,qBAAmB,EAAE,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QACvC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAC;QAEtE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAUD,sCAAgB,GAAhB,UAAoC,CAAS,EAAE,CAAI;QACjD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,oEAAoE;aAChE,cAAY,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IAWD,6CAAuB,GAAvB,UAAwB,CAAU,EAAE,CAAU;QAC5C,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,2DAA2D;aACvD,0BAAwB,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,4DAA4D;aACxD,0BAAwB,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IAkBD,4BAAM,GAAN,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,MAAc,EAClE,OAAe;QACjB,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,qDAAmD,CAAC,CAAC,IAAI,MAAG,CAAC,CAAC;QAClE,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,IAAI,KAAK,CAAC,EAClB,wDAAwD;aACjD,OAAO,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC5B,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAI,CAAC,MAAM,CACP,MAAM,CAAC,IAAI,KAAK,CAAC,EACjB,uDAAuD;iBAChD,MAAM,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAC/B,sCAAoC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,mBAAgB;aAC1D,6BAA2B,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,MAAG,CAAA,CAAC,CAAC;QAGxD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;IAcD,oCAAc,GAAd,UACI,CAAU,EAAE,EAAW,EAAE,OAAgB,EAAE,MAAc,EACzD,GAAW;QACb,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,2DAA2D;aACpD,CAAC,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QACvB,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,EACb,4DAA4D;aACrD,EAAE,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,IAAI,KAAK,CAAC,EAClB,iEAAiE;aAC1D,OAAO,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAC/B,yCAAuC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,YAAS;aACtD,oCAAkC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,MAAG,CAAA,CAAC,CAAC;QAC/D,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAChC,2CAAyC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,YAAS;aACzD,qCAAmC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAI,CAAA,CAAC,CAAC;QAEjE,IAAM,cAAc,GAChB,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAE7D,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAE9B,MAAM,CAAC,cAAc,CAAC;IACxB,CAAC;IAgBD,qCAAe,GAAf,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,MAAc,EAClE,GAAW;QACb,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,2DAA2D;aACpD,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QACtB,IAAI,CAAC,MAAM,CACP,OAAO,CAAC,IAAI,KAAK,CAAC,EAClB,4DAA4D;aACxD,UAAQ,OAAO,CAAC,IAAM,CAAA,CAAC,CAAC;QAChC,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAI,CAAC,MAAM,CACP,MAAM,CAAC,IAAI,KAAK,CAAC,EACjB,uFACY,MAAM,CAAC,IAAI,MAAG,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAC/B,+CAA6C,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,YAAS;aAC5D,mCAAiC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,MAAG,CAAA,CAAC,CAAC;QAE9D,MAAM,CAAC,IAAI,CAAC,KAAK,CACb,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACrE,CAAC;IAaD,6BAAO,GAAP,UAAQ,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QAC5D,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,kDAAkD,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;QACvE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;IAaD,qCAAe,GAAf,UACI,EAAW,EAAE,CAAU,EAAE,KAAa,EAAE,MAAc,EACtD,GAAW;QACb,IAAI,CAAC,MAAM,CACP,EAAE,CAAC,IAAI,KAAK,CAAC,EACb,2DAA2D;aACpD,EAAE,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QACvB,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,0DAA0D;aACnD,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAEtB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7E,CAAC;IAaD,6BAAO,GAAP,UAAQ,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QAC5D,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,qDAAmD,CAAC,CAAC,IAAI,MAAG,CAAC,CAAC;QAClE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;IAYD,6BAAO,GAAP,UAAQ,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QAC5D,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,qDAAmD,CAAC,CAAC,IAAI,MAAG,CAAC,CAAC;QAClE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;IAcD,sCAAgB,GAAhB,UACI,CAAU,EAAE,UAA4B,EAAE,YAAoB;QAApB,6BAAA,EAAA,oBAAoB;QAChE,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,8DAA4D,CAAC,CAAC,IAAI,MAAG,CAAC,CAAC;QAC3E,IAAI,CAAC,MAAM,CACP,UAAU,CAAC,MAAM,KAAK,CAAC,EACvB,8DAA8D;aACvD,UAAU,MAAG,CAAA,CAAC,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CACb,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC;IAClE,CAAC;IAgBD,0CAAoB,GAApB,UACI,CAAU,EAAE,IAAqB,EAAE,QAAyB,EAC5D,eAAsB,EAAE,KAAuB,EAC/C,MAAwB;QADxB,gCAAA,EAAA,sBAAsB;QAExB,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,CAAC,EACZ,+DAA+D;aACxD,CAAC,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QACtB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC,EAClC,mEAAmE;aAC/D,cAAY,IAAI,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,CACP,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC,EAC1C,mEAAmE;aAC/D,kBAAgB,QAAQ,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC1C,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC;YAClB,IAAI,CAAC,MAAM,CACP,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,EACpC,gEAAgE;iBAC5D,kBAAgB,KAAM,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC1C,CAAC;QACD,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAI,CAAC,MAAM,CACP,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,EACtC,iEAAiE;iBAC7D,kBAAgB,MAAO,CAAC,IAAI,MAAG,CAAA,CAAC,CAAC;QAC3C,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,4BAA4B,CAC/C,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1D,CAAC;IAKH,kBAAC;AAAD,CA5gCA,AA4gCC,IAAA;AA5gCqB,kCAAW;AA8gCjC,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,+DAAO,CAAA;IACP,qEAAU,CAAA;AACZ,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;;;;;;;;;;;;;;;ACzhCD,6CAA+C;AAC/C,8BAAgC;AAEhC,+CAAiD;AACjD,2CAA6C;AAC7C,+BAAsD;AACtD,qCAA8E;AAE9E;IAAoC,kCAAW;IAC7C,wBAAY,QAAgB;QAAhB,yBAAA,EAAA,gBAAgB;eAC1B,kBAAM,QAAQ,CAAC;IACjB,CAAC;IAES,sCAAa,GAAvB,UAA2C,OAAU;QACnD,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,IAAI,YAAY,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAC,CAAC,CAAC;IACtE,CAAC;IAES,wCAAe,GAAzB,UACI,OAAW,EAAE,QAAkB;QACjC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,OAAO,CAAK,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAES,wCAAe,GAAzB,UACI,KAAc,EAAE,WAA6B,EAC7C,UAA4B;QAC9B,IAAM,MAAM,GAAG,iBAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACzC,IAAI,CAAC,cAAc,CACf,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAChE,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,uCAAc,GAAxB,UACI,MAAe,EAAE,iBAAmC,EACpD,gBAAkC,EAAE,IAAa,EACjD,eAAiC,EACjC,cAAgC;QAClC,WAAW,CAAC,cAAc,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAC7D,IAAM,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;QACrC,IAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACnC,IAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;QACpD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YAC3B,IAAM,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1E,IAAM,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;YAChE,IAAM,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;YACjD,IAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;YACtE,IAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,IAAM,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;YAC/C,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAES,yCAAgB,GAA1B,UAA2B,EAAW,EAAE,EAAW,EAAE,IAAY;QAC/D,IAAM,WAAW,GACb,aAAa,CAAC,0BAA0B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEvE,IAAM,MAAM,GAAG,iBAAO,CAAC,KAAK,CAAU,WAAW,CAAC,CAAC;QAEnD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAExC,IAAM,KAAK,GAA6B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAClD,IAAI,KAAK,SAAQ,CAAC;oBAClB,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;wBACjC,KAAK,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAC1B,CAAC;oBAAC,IAAI,CAAC,CAAC;wBACN,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;wBACvB,IAAA,aAAE,EAAE,aAAE,EAAE,aAAE,CAAU;wBAC3B,KAAK,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;oBAC7B,CAAC;oBAED,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,gDAAuB,GAAjC,UAAqD,CAAS,EAAE,CAAI;QAClE,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACrB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YAC7C,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACtC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAC1D,CAAC;IAES,+CAAsB,GAAhC,UACI,EAAU,EAAE,CAAI,EAAE,EAAU,EAAE,CAAI;QACpC,IAAM,OAAO,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzC,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,KAAK,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;QACvB,IAAM,KAAK,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;QACvB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,OAAO,EAAC,CAAC,CAAC;IACrD,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAS,EAAE,CAAI;QACnE,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACrB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IACvD,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAS,EAAE,CAAI;QACnE,IAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjC,IAAM,MAAM,GAAG,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAErD,IAAI,CAAC,OAAO,EAAE,CAAC;QAEf,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAI,EAAE,CAAS;QACnE,IAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjC,IAAM,MAAM,GAAG,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAErD,IAAI,CAAC,OAAO,EAAE,CAAC;QAEf,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI;QAC3C,MAAM,CAAC,IAAI,CAAC,wBAAwB,CAAC,gBAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI,EAAE,CAAI;QACjD,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAI,gBAAM,CAAC,GAAG,EAAE,CAAC,EAAE,gBAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACtE,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI,EAAE,CAAI;QACjD,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAI,gBAAM,CAAC,GAAG,EAAE,CAAC,EAAE,gBAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;IAES,uCAAc,GAAxB,UACI,CAAU,EAAE,CAAU,EAAE,YAAwC,EAChE,YAAwC;QADhB,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;QAChE,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;QAC1C,IAAM,SAAS,GACX,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE3E,IAAM,OAAO,GACT,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAM,QAAQ,GACV,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE3E,IAAM,YAAY,GAAG,UAAC,MAAe,EAAE,CAAS,EAAE,CAAS;YACvD,OAAA,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;QAAhB,CAAgB,CAAC;QACrB,IAAM,gBAAgB,GAAG,UAAC,MAAe,EAAE,CAAS,EAAE,CAAS;YAC3D,OAAA,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;QAAhB,CAAgB,CAAC;QAErB,IAAM,OAAO,GAAG,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC;YACxD,YAAY;YACZ,gBAAgB,CAAC;QACrB,IAAM,OAAO,GAAG,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC;YACxD,YAAY;YACZ,gBAAgB,CAAC;QACrB,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC;QACpD,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;YACjC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC;gBAClC,IAAI,GAAG,GAAG,CAAC,CAAC;gBACZ,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,EAAE,CAAC,EAAE,CAAC;oBAEnC,GAAG,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC7C,CAAC;gBACD,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC;YACxB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IAES,+CAAsB,GAAhC,UAAoD,CAAI,EAAE,CAAI;QAC5D,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IACvD,CAAC;IAES,wDAA+B,GAAzC,UAA0C,CAAU,EAAE,CAAU;QAC9D,IAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,IAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhD,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;QACjD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;YACtC,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;gBACtC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACvD,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAES,uCAAc,GAAxB,UAA4C,CAAI,EAAE,CAAI;QACpD,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IACvD,CAAC;IAES,qDAA4B,GAAtC,UAA0D,CAAS,EAAE,CAAI;QAEvE,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACvB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IACvD,CAAC;IAES,qDAA4B,GAAtC,UAA0D,CAAI,EAAE,CAAS;QAEvE,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACvB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IACvD,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAES,uCAAc,GAAxB,UAAyB,OAAgB;QACvC,IAAI,GAAG,GAAG,MAAM,CAAC,SAAS,CAAC;QAC3B,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;QAClB,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,EAAE,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC;gBAChB,GAAG,GAAG,KAAK,CAAC;gBACZ,QAAQ,GAAG,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAES,uCAAc,GAAxB,UAAyB,OAAgB;QACvC,IAAI,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACnC,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;QAClB,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,EAAE,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC;gBAChB,GAAG,GAAG,KAAK,CAAC;gBACZ,QAAQ,GAAG,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAES,6CAAoB,GAA9B,UAA+B,EAAW,EAAE,EAAW;QACrD,IAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;QAC9C,IAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;QAC9C,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACrC,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC;IAC5C,CAAC;IAES,qCAAY,GAAtB,UAAuB,OAAgB,EAAE,CAAS;QAEhD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,IAAM,gBAAgB,GAA0C,EAAE,CAAC;QACnE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,gBAAgB,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC,CAAC;QACtD,CAAC;QACD,gBAAgB,CAAC,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,IAAM,UAAU,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;QACvC,IAAM,WAAW,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;QACxC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,UAAU,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAC1C,WAAW,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7C,CAAC;QACD,MAAM,CAAC,EAAC,MAAM,EAAE,iBAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,iBAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAAC,CAAC;IAC9E,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,EAAE,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC;gBAChB,GAAG,GAAG,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,EAAE,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC;gBAChB,GAAG,GAAG,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QACD,MAAM,CAAC,gBAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IAC7D,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IAC7D,CAAC;IAES,0CAAiB,GAA3B,UAA4B,OAAgB;QAC1C,IAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC/C,IAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtB,IAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtB,IAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtB,IAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAEjC,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,CAAC,CAAC,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,OAAO,EAAE,CAAC;QAEZ,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAChE,CAAC;IAES,wCAAe,GAAzB,UAA6C,OAAU;QACrD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAChE,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAChE,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAChE,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpD,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACvC,IAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,YAAY,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAC5D,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;IAChE,CAAC;IAMS,uCAAc,GAAxB,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,MAAc,EAClE,GAAW;QACP,IAAA,YAAoC,EAAnC,aAAK,EAAE,aAAK,EAAE,kBAAU,CAAY;QAC3C,IAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,IAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACrC,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACrE,IAAM,CAAC,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACrC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE,CAAC;YACxC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;gBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;gBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;gBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAC;gBACpD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;oBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;oBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAC;oBACpD,IAAI,OAAO,GAAG,CAAC,CAAC;oBAChB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;wBACzB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;4BACzB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,UAAU,EAAE,EAAE,EAAE,EAAE,CAAC;gCACvC,IAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCAChC,IAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCAC3C,OAAO,IAAI,KAAK,GAAG,MAAM,CAAC;4BAC5B,CAAC;wBACH,CAAC;oBACH,CAAC;oBACD,IAAM,IAAI,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;oBACnD,CAAC,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAES,+CAAsB,GAAhC,UACI,CAAU,EAAE,EAAW,EAAE,OAAgB,EAAE,MAAc,EACzD,GAAW;QACb,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAM,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5D,IAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAClC,IAAM,EAAE,GAAG,IAAI,CAAC,uBAAuB,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACxE,MAAM,CAAC,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,CAAC;IACtB,CAAC;IAMS,gDAAuB,GAAjC,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,UAAkB,EACtE,OAAe;QACjB,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;QAChC,IAAM,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxC,IAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,IAAA,YAAgC,EAA/B,aAAK,EAAE,aAAK,EAAE,cAAM,CAAY;QAGvC,IAAM,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAClD,IAAM,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAElD,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,EACvE,GAAG,CAAC,CAAC;QACT,IAAM,CAAC,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACrC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,cAAc,EAAE,EAAE,EAAE,EAAE,CAAC;YAC3C,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;gBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,GAAG,CAAC;gBAC1B,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC;gBAC5D,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC;gBAE/D,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,GAAG,CAAC;oBAC1B,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC;oBAC5D,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC;oBAE/D,IAAI,OAAO,GAAG,CAAC,CAAC;oBAChB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBACtC,IAAM,EAAE,GAAG,EAAE,GAAG,UAAU,GAAG,QAAQ,CAAC;wBAEtC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BACtC,IAAM,EAAE,GAAG,EAAE,GAAG,UAAU,GAAG,QAAQ,CAAC;4BAEtC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,eAAe,EAAE,EAAE,EAAE,EAAE,CAAC;gCAC5C,IAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCAChC,IAAM,MAAM,GACR,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCACxD,OAAO,IAAI,KAAK,GAAG,MAAM,CAAC;4BAC5B,CAAC;wBACH,CAAC;oBACH,CAAC;oBACD,IAAM,IAAI,GAAG,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;oBACjD,CAAC,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAMS,kDAAyB,GAAnC,UACI,CAAU,EAAE,WAAoB,EAAE,UAAkB,EACpD,OAAe;QACjB,IAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;QAChC,IAAM,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5C,IAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvC,IAAA,YAAgC,EAA/B,aAAK,EAAE,aAAK,EAAE,cAAM,CAAY;QAGvC,IAAM,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAClD,IAAM,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAElD,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,EACvE,GAAG,CAAC,CAAC;QACT,IAAM,CAAC,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAErC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,cAAc,EAAE,EAAE,EAAE,EAAE,CAAC;YAC3C,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;gBACvC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBAEvC,IAAM,QAAQ,GAAG,EAAE,GAAG,GAAG,CAAC;oBAC1B,IAAM,QAAQ,GAAG,EAAE,GAAG,GAAG,CAAC;oBAC1B,IAAI,OAAO,GAAG,CAAC,CAAC;oBAChB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBAClC,IAAM,EAAE,GAAG,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;wBACxC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;4BACnD,QAAQ,CAAC;wBACX,CAAC;wBACD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BAClC,IAAM,EAAE,GAAG,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;4BACxC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gCACnD,QAAQ,CAAC;4BACX,CAAC;4BACD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,eAAe,EAAE,EAAE,EAAE,EAAE,CAAC;gCAC5C,IAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCAChC,IAAM,MAAM,GACR,WAAW,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gCAC5D,OAAO,IAAI,KAAK,GAAG,MAAM,CAAC;4BAC5B,CAAC;wBACH,CAAC;oBACH,CAAC;oBACD,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAED,yCAAgB,GAAhB,UACI,CAAU,EAAE,EAAW,EAAE,KAAa,EAAE,MAAc,EACtD,OAAe;QACjB,IAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAM,WAAW,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChC,IAAM,YAAY,GACd,SAAS,CAAC,qBAAqB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;QACpE,IAAM,EAAE,GAAG,iBAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAEvC,IAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE5B,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;YAClC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;YAC9D,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,GAAG,OAAO,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC;YAErE,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;gBAClC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;gBAC9D,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,GAAG,OAAO,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC;gBAErE,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,UAAU,EAAE,EAAE,EAAE,EAAE,CAAC;oBACvC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE,CAAC;wBAExC,IAAI,OAAO,GAAG,CAAC,CAAC;wBAChB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BACtC,IAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC;4BACtC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;gCACtC,IAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC;gCACtC,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;4BACpD,CAAC;wBACH,CAAC;wBACD,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;oBAClC,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;IAED,sCAAa,GAAb,UAAc,EAAW;QACvB,IAAM,WAAW,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChC,IAAM,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAM,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;QAC7C,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE,CAAC;YACxC,IAAI,GAAG,GAAG,CAAC,CAAC;YACZ,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;gBACjC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;oBACjC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC1B,CAAC;YACH,CAAC;YACD,MAAM,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAES,0CAAiB,GAA3B,UAA+C,CAAI,EAAE,MAAgB;QACnE,IAAM,QAAQ,GAAa,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC7C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,IAAM,YAAY,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAM,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC7B,IAAM,MAAM,GAAG,iBAAO,CAAC,IAAI,CAAI,QAAQ,EAAE,EAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAC;QACjE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC;YAChC,IAAM,GAAG,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAG5B,IAAM,MAAM,GAAa,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC/C,GAAG,CAAC,CAAC,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAC,EAAE,EAAE,CAAC;gBACvC,MAAM,CAAC,GAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,GAAC,CAAC,CAAC,CAAC;YAC7B,CAAC;YAED,IAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC3C,YAAY,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAEO,6BAAI,GAAZ,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW,EACtD,QAA2B;QACvB,IAAA,YAA+B,EAA9B,aAAK,EAAE,aAAK,EAAE,aAAK,CAAY;QACtC,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACtD,IAAM,CAAC,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACrC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;YAC/B,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;gBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;gBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;gBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;gBAChD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBACvC,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;oBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;oBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;oBAGhD,IAAI,WAAW,GACX,CAAC,QAAQ,KAAK,KAAK,GAAG,MAAM,CAAC,iBAAiB;wBACxB,MAAM,CAAC,iBAAiB,CAAC,CAAC;oBACpD,IAAI,QAAQ,GAAG,CAAC,CAAC;oBAEjB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;wBACzB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;4BACzB,IAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;4BAC/B,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gCACjB,WAAW,GAAG,GAAG,CAAC;gCAClB,QAAQ,GAAG,GAAG,CAAC;gCACf,KAAK,CAAC;4BACR,CAAC;4BACD,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,KAAK,IAAI,KAAK,GAAG,WAAW,CAAC;gCAC3C,CAAC,QAAQ,KAAK,KAAK,IAAI,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gCAChD,WAAW,GAAG,KAAK,CAAC;4BACtB,CAAC;4BAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC;gCAC9B,QAAQ,IAAI,KAAK,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;4BACtC,CAAC;wBACH,CAAC;wBACD,EAAE,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;4BACvB,KAAK,CAAC;wBACR,CAAC;oBACH,CAAC;oBACD,CAAC,CAAC,GAAG,CAAC,QAAQ,KAAK,KAAK,GAAG,QAAQ,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;gBAChE,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAED,yCAAgB,GAAhB,UAAiB,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QAC/D,IAAA,YAA+B,EAA9B,aAAK,EAAE,aAAK,EAAE,aAAK,CAAY;QACtC,IAAM,WAAW,GACb,SAAS,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACvE,IAAM,YAAY,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAChD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;YAC/B,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;gBAC3C,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;gBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;gBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;gBAChD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBAC3C,IAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;oBACnC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;oBACpC,IAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;oBAChD,IAAI,QAAQ,GAAG,MAAM,CAAC,iBAAiB,CAAC;oBACxC,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC;oBACrB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;wBACzB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BACtC,IAAM,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC;4BACzB,IAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;4BAC/B,EAAE,CAAC,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC;gCACrB,QAAQ,GAAG,KAAK,CAAC;gCACjB,WAAW,GAAG,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC;4BAChC,CAAC;wBACH,CAAC;oBACH,CAAC;oBACD,YAAY,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,YAAY,CAAC;IACtB,CAAC;IAES,gDAAuB,GAAjC,UACI,EAAW,EAAE,CAAU,EAAE,KAAa,EAAE,UAAkB,EAC1D,OAAe;QACjB,IAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAC1E,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;QAC1B,IAAA,aAAkC,EAAjC,cAAM,EAAE,cAAM,EAAE,aAAK,CAAa;QAGzC,IAAM,aAAa,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QACpD,IAAM,aAAa,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;QAEpD,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,aAAa,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QACjE,IAAM,EAAE,GAAG,iBAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAEtC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;YAC/B,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC;gBAC3C,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC;oBAE3C,IAAM,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC;oBAC5B,IAAM,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC;oBAC5B,IAAI,OAAO,GAAG,CAAC,CAAC;oBAChB,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;wBAClC,IAAM,GAAG,GAAG,CAAC,SAAS,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;wBAC1C,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,GAAG,IAAI,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;4BACxD,QAAQ,CAAC;wBACX,CAAC;wBACD,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC;4BAClC,IAAM,GAAG,GAAG,CAAC,SAAS,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;4BAC1C,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,GAAG,IAAI,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;gCACxD,QAAQ,CAAC;4BACX,CAAC;4BACD,IAAM,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;4BACjE,IAAM,MAAM,GAAG,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC;4BAE/B,IAAM,IAAI,GAAG,MAAM,KAAK,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;4BACvC,EAAE,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;gCACf,QAAQ,CAAC;4BACX,CAAC;4BAED,IAAM,KAAK,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;4BAClC,OAAO,IAAI,KAAK,GAAG,IAAI,CAAC;wBAC1B,CAAC;oBACH,CAAC;oBACD,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC/B,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAES,iDAAwB,GAAlC,UACI,CAAU,EAAE,UAA4B,EACxC,YAAqB;QACvB,IAAM,MAAM,GAAG,iBAAO,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEzE,IAAM,kBAAkB,GACpB,YAAY,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QAC1E,IAAM,mBAAmB,GAAG,YAAY;YACpC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3D,MAAM,CAAC,KAAK,CAAC;QACjB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBACzC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAIzC,IAAM,aAAa,GACf,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC3D,IAAM,aAAa,GACf,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;oBAE3D,IAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;oBACjD,IAAM,aAAa,GACf,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;oBACvD,IAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;oBACjD,IAAM,aAAa,GACf,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;oBAEvD,IAAM,OAAO,GAAG,CAAC,CAAC,GAAG,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;oBACzD,IAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,aAAa,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;oBAC3D,IAAM,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,cAAc,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;oBACzD,IAAM,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;oBAE3D,IAAM,OAAO,GAAG,aAAa,GAAG,cAAc,CAAC;oBAC/C,IAAM,OAAO,GAAG,aAAa,GAAG,cAAc,CAAC;oBAE/C,IAAM,KAAG,GAAG,OAAO,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC;oBACrD,IAAM,MAAM,GAAG,UAAU,GAAG,CAAC,WAAW,GAAG,UAAU,CAAC,GAAG,OAAO,CAAC;oBACjE,IAAM,QAAQ,GAAG,KAAG,GAAG,CAAC,MAAM,GAAG,KAAG,CAAC,GAAG,OAAO,CAAC;oBAEhD,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAChC,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,qDAA4B,GAAtC,UACI,CAAU,EAAE,IAAqB,EAAE,QAAyB,EAC5D,eAAsB,EAAE,KAAuB,EAC/C,MAAwB;QADxB,gCAAA,EAAA,sBAAsB;QAExB,IAAM,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAM,UAAU,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACpC,IAAM,cAAc,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC5C,IAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC,SAAS,EAAE,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtE,IAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzE,IAAM,SAAS,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAEnD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,SAAS,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC;gBAChD,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;oBAC5C,WAAW,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC;oBACnC,IAAI,CAAC,IAAI,CACL,cAAc,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC;QAC3E,CAAC;QACD,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAU,CAAC,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;IAC7D,CAAC;IACH,qBAAC;AAAD,CA12BA,AA02BC,CA12BmC,kBAAW,GA02B9C;AA12BY,wCAAc;;;;;;;;;;;;;;;ACR3B,8BAAgC;AAEhC,+CAAiD;AACjD,uCAAyC;AACzC,+BAAsD;AACtD,mCAAqC;AACrC,qCAA8E;AAC9E,2DAA6D;AAC7D,2DAA6D;AAC7D,6DAAqD;AACrD,2DAA6D;AAC7D,qDAAuD;AACvD,mDAAqD;AACrD,qDAAuD;AACvD,mDAAqD;AACrD,6DAA+D;AAC/D,2CAA6C;AAC7C,2CAA6C;AAC7C,yCAA2C;AAC3C,uDAAmD;AACnD,+CAAiD;AACjD,yCAA2C;AAC3C,qDAAuD;AACvD,qEAAuE;AACvE,mDAAqD;AACrD,mDAAqD;AACrD,+CAAiD;AACjD,+CAAiD;AACjD,yCAA2C;AAC3C,2CAA6C;AAC7C,qDAAuD;AACvD,2CAA6C;AAC7C,iDAAmD;AACnD,iEAAmE;AACnE,yDAA2D;AAC3D,iDAAmD;AACnD,2CAA6C;AAC7C,2DAAuD;AACvD,2CAA6C;AAC7C,+CAAiD;AAEjD,IAAM,WAAW,GAAG,QAAQ,CAAC;AAC7B,IAAM,kBAAkB,GAAG,cAAc,CAAC;AAC1C,IAAM,WAAW,GAAG,QAAQ,CAAC;AAE7B,IAAM,cAAc,GAAG,WAAW,CAAC;AAEnC,IAAM,SAAS,GAAG,MAAM,CAAC;AACzB,IAAM,WAAW,GAAG,QAAQ,CAAC;AAG7B,IAAM,mBAAmB,GAAG,cAAc,CAAC;AAC3C,IAAM,WAAW,GAAG,QAAQ,CAAC;AAG7B,IAAM,SAAS,GAAG,MAAM,CAAC;AACzB,IAAM,SAAS,GAAG,MAAM,CAAC;AACzB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,YAAY,GAAG,SAAS,CAAC;AAC/B,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,QAAQ,GAAG,KAAK,CAAC;AACvB,IAAM,SAAS,GAAG,MAAM,CAAC;AACzB,IAAM,cAAc,GAAG,WAAW,CAAC;AACnC,IAAM,YAAY,GAAG,SAAS,CAAC;AAC/B,IAAM,oBAAoB,GAAG,cAAc,CAAC;AAG5C,IAAM,WAAW,GAAG,MAAM,CAAC;AAC3B,IAAM,qBAAqB,GAAG,gBAAgB,CAAC;AAC/C,IAAM,gBAAgB,GAAG,WAAW,CAAC;AACrC,IAAM,gBAAgB,GAAG,WAAW,CAAC;AACrC,IAAM,aAAa,GAAG,SAAS,CAAC;AAChC,IAAM,uBAAuB,GAAG,cAAc,CAAC;AAC/C,IAAM,sBAAsB,GAAG,kBAAkB,CAAC;AAClD,IAAM,aAAa,GAAG,SAAS,CAAC;AAChC,IAAM,aAAa,GAAG,SAAS,CAAC;AAEhC,IAAM,oBAAoB,GAAG,aAAa,CAAC;AAE3C,6BACI,iBAAmC,EAAE,gBAAkC,EACvE,cAAgC;IAClC,IAAM,SAAS,GAAM,iBAAiB,CAAC,CAAC,CAAC,SAAI,iBAAiB,CAAC,CAAC,CAAG,CAAC;IACpE,IAAM,WAAW,GAAM,gBAAgB,CAAC,CAAC,CAAC,SAAI,gBAAgB,CAAC,CAAC,CAAG,CAAC;IACpE,IAAM,WAAW,GAAM,cAAc,CAAC,CAAC,CAAC,SAAI,cAAc,CAAC,CAAC,CAAG,CAAC;IAChE,MAAM,CAAI,SAAS,SAAI,SAAS,SAAI,WAAW,SAAI,WAAa,CAAC;AACnE,CAAC;AAED;IAAoC,kCAAW;IAM7C,wBAAY,KAAoB,EAAE,QAAe;QAAf,yBAAA,EAAA,eAAe;QAAjD,YACE,kBAAM,QAAQ,CAAC,SAahB;QAjBO,kBAAY,GAAkC,EAAE,CAAC;QAKvD,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC;YAClB,IAAM,EAAE,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;YAC3C,KAAI,CAAC,KAAK,GAAG,IAAI,4BAAY,CAAC,EAAE,CAAC,CAAC;YAClC,KAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAClC,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,KAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,KAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACnC,CAAC;QAED,KAAI,CAAC,cAAc,GAAG,IAAI,gCAAc,CAAC,KAAI,CAAC,KAAK,CAAC,CAAC;QAErD,OAAO,CAAC,aAAa,CAAC,KAAI,CAAC,KAAK,EAAE,KAAI,CAAC,cAAc,CAAC,CAAC;;IACzD,CAAC;IAED,wCAAe,GAAf;QACE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAES,sCAAa,GAAvB,UAA2C,OAAU;QACnD,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,mBAAmB,CAAC,cAAc,EAAE,cAAc,EAAE,cAAc,CAAC,EACnE,cAAM,OAAA,QAAQ,CAAC,uBAAuB,CAClC,cAAc,EAAE,cAAc,EAAE,cAAc,CAAC,EAD7C,CAC6C,CAAC,CAAC;QAEzD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,IAAI,CACT,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EACjE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QAE3E,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,wCAAe,GAAzB,UACI,OAAW,EAAE,QAAkB;QACjC,IAAI,WAA6B,CAAC;QAElC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;YACxB,KAAK,CAAC;gBACJ,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACrB,KAAK,CAAC;YACR,KAAK,CAAC;gBACJ,WAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC/B,KAAK,CAAC;YACR,KAAK,CAAC;gBACJ,WAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;gBACzC,KAAK,CAAC;YACR,KAAK,CAAC;gBACJ,WAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvD,KAAK,CAAC;YACR;gBACE,MAAM,KAAK,CACP,mBAAiB,QAAQ,CAAC,MAAM,6BAA0B;oBAC1D,kBAAkB,CAAC,CAAC;QAC5B,CAAC;QAED,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAC9D,IAAI,WAAe,CAAC;QACpB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;YACnD,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAC1D,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,CAAC,WAAW,CAAC,OAAO,CAAK,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAES,wCAAe,GAAzB,UACI,KAAc,EAAE,WAA6B,EAC7C,UAA4B;QAC9B,IAAM,MAAM,GAAG,iBAAO,CAAC,IAAI,CAAU,UAAU,EAAE;YAC/C,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC;YACvD,cAAc,EAAE,UAAU;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,CACf,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAChE,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,uCAAc,GAAxB,UACI,MAAe,EAAE,iBAAmC,EACpD,gBAAkC,EAAE,IAAa,EACjD,eAAiC,EACjC,cAAgC;QAClC,IAAM,aAAa,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;QACjD,IAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,mBAAmB,CAAC,aAAa,EAAE,gBAAgB,EAAE,cAAc,CAAC,EACpE,cAAM,OAAA,QAAQ,CAAC,uBAAuB,CAClC,aAAa,EAAE,gBAAgB,EAAE,cAAc,CAAC,EAD9C,CAC8C,CAAC,CAAC;QAE1D,QAAQ,CAAC,IAAI,CACT,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,UAAU,EAAE,EAAE,aAAa,EACvD,iBAAiB,EAAE,gBAAgB,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,WAAW,EACnE,eAAe,EAAE,cAAc,CAAC,CAAC;IACvC,CAAC;IAES,yCAAgB,GAA1B,UAA2B,EAAW,EAAE,EAAW,EAAE,IAAY;QAC/D,IAAM,YAAY,GACd,SAAS,CAAC,qBAAqB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAM,YAAY,GACd,SAAS,CAAC,qBAAqB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAI9C,IAAM,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;QAC5D,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;YACtD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;YAC3C,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;QACD,IAAM,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;QAC5D,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;YACtD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;YAC3C,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;QAED,IAAM,cAAc,GAChB,aAAa,CAAC,0BAA0B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEvE,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,WAAW,SAAI,EAAE,CAAC,KAAK,SAAI,EAAE,CAAC,KAAK,SAAI,IAAM,EAChD,cAAM,OAAA,YAAY,CAAC,uBAAuB,CACtC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,CAAC,EADvC,CACuC,CAAC,CAAC;QAEnD,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;QACvE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,YAAY,CAAC,QAAQ,CACjB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAChE,cAAc,CAAC,CAAC;QAEpB,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACd,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACd,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,cAAc,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC5E,CAAC;IAES,gDAAuB,GAAjC,UAAqD,CAAS,EAAE,CAAI;QAClE,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAI,EAAE,CAAS;QACnE,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAS,EAAE,CAAI;QACnE,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,+CAAsB,GAAhC,UACI,EAAU,EAAE,CAAI,EAAE,EAAU,EAAE,CAAI;QACpC,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACjC,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;YAClD,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,mBAAmB,EAAE,cAAM,OAAA,gBAAgB,CAAC,uBAAuB,EAAE,EAA1C,CAA0C,CAAC,CAAC;QAE3E,IAAM,cAAc,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAC7C,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,gBAAgB,CAAC,iBAAiB,CAC9B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EACtE,cAAc,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,aAAa,CAAC,CAAC;QAExE,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC5E,CAAC;IAES,iDAAwB,GAAlC,UAAsD,CAAS,EAAE,CAAI;QACnE,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI;QAC3C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,QAAQ,EAAE,cAAM,OAAA,OAAO,CAAC,uBAAuB,EAAE,EAAjC,CAAiC,CAAC,CAAC;QAEvD,IAAM,cAAc,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAC7C,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,OAAO,CAAC,GAAG,CACP,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EACtD,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CAAI,CAAC,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC5E,CAAC;IAEO,uCAAc,GAAtB,UAA0C,CAAI,EAAE,eAE/C;QACC,IAAM,SAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAExC,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,YAAY,EAAE,cAAM,OAAA,WAAW,CAAC,uBAAuB,EAAE,EAArC,CAAqC,CAAC,CAAC;QAE/D,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;QAC1E,WAAW,CAAC,OAAO,CACf,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAC/D,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3D,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,CAAC,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAC,CAAC,CAAC;IAC1E,CAAC;IAES,uCAAc,GAAxB,UACI,CAAU,EAAE,CAAU,EAAE,YAA+B,EACvD,YAA+B;QACjC,IAAM,SAAS,GACX,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAM,WAAW,GACb,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAM,WAAW,GACb,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAM,QAAQ,GAAqB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QAC9D,IAAM,WAAW,GACb,UAAU,CAAC,+BAA+B,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACxE,IAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QACnE,IAAM,GAAG,GAAG,IAAI,iBAAO,CACnB,QAAQ,EAAE,EAAC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAC,CAAC,CAAC;QAElE,IAAM,GAAG,GAAG,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACvD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,WAAW,SAAI,GAAG,SAAI,YAAY,SAAI,YAAc,EACvD,cAAM,OAAA,UAAU,CAAC,iBAAiB,CAC9B,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,YAAY,CAAC,EADpC,CACoC,CAAC,CAAC;QAEhD,UAAU,CAAC,cAAc,CACrB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,UAAU,EAC/D,WAAW,CAAC,CAAC;QAEjB,MAAM,CAAC,GAAG,CAAC;IACb,CAAC;IAES,+CAAsB,GAAhC,UAAoD,CAAI,EAAE,CAAI;QAC5D,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,wDAA+B,GAAzC,UAA0C,CAAU,EAAE,CAAU;QAC9D,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IAES,qDAA4B,GAAtC,UACI,CAAU,EAAE,IAAqB,EAAE,QAAyB,EAC5D,eAAuB,EAAE,KAAuB,EAChD,MAAwB;QAC1B,IAAM,SAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAExC,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAM,qBAAqB,GACvB,IAAI,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;QACjD,IAAI,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;QACjE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;YAC3D,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;YACxD,YAAY,GAAG,qBAAqB,CAAC;YACrC,WAAW,GAAG,IAAI,CAAC;QACrB,CAAC;QAED,IAAI,eAAe,GAAG,KAAK,CAAC;QAC5B,IAAM,yBAAyB,GAC3B,QAAQ,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;QACzD,IAAI,gBAAgB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;QACzE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,yBAAyB,CAAC,CAAC,CAAC,CAAC;YACnE,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,yBAAyB,CAAC,CAAC;YACpE,gBAAgB,GAAG,yBAAyB,CAAC;YAC7C,eAAe,GAAG,IAAI,CAAC;QACzB,CAAC;QAED,IAAI,aAAa,GAA0B,IAAI,CAAC;QAChD,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC;YAClB,IAAM,sBAAsB,GACxB,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAEnD,aAAa,GAAG,KAAK,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,CAAC;YAChE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC;gBAC7D,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC;gBAC3D,aAAa,GAAG,sBAAsB,CAAC;gBACvC,YAAY,GAAG,IAAI,CAAC;YACtB,CAAC;QACH,CAAC;QAED,IAAI,cAAc,GAA0B,IAAI,CAAC;QACjD,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAM,uBAAuB,GACzB,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAErD,cAAc,GAAG,MAAM,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,CAAC;YACnE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;gBAC/D,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;gBAC9D,cAAc,GAAG,uBAAuB,CAAC;gBACzC,aAAa,GAAG,IAAI,CAAC;YACvB,CAAC;QACH,CAAC;QAED,IAAM,cAAc,GAAqB,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAE/D,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,cAAc,SAAI,SAAS,SAAI,YAAY,SAAI,gBAAgB,MAAG;aAC9D,aAAc,SAAI,cAAe,SAAI,eAAiB,CAAA,EAC7D,cAAM,OAAA,aAAa,CAAC,uBAAuB,CACvC,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EACzD,aAAa,EAAE,eAAe,CAAC,EAF7B,CAE6B,CAAC,CAAC;QAEzC,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,aAAa,CAAC,kBAAkB,CAC5B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,EACjE,YAAY,EAAE,QAAQ,CAAC,UAAU,EAAE,EAAE,gBAAgB,EACrD,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC,UAAU,EAAE,GAAG,IAAI,EAC3C,MAAM,IAAI,IAAI,GAAG,cAAc,GAAG,IAAI,EACtC,KAAK,IAAI,IAAI,GAAG,KAAK,CAAC,UAAU,EAAE,GAAG,IAAI,EACzC,KAAK,IAAI,IAAI,GAAG,aAAa,GAAG,IAAI,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;QAEzE,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;YAChB,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC;QACD,EAAE,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC;YACpB,QAAQ,CAAC,OAAO,EAAE,CAAC;QACrB,CAAC;QACD,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;YACjB,KAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QACD,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;YAClB,MAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,CAAC,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IACzE,CAAC;IAES,0CAAiB,GAA3B,UAA+C,CAAI,EAAE,MAAgB;QACnE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC5C,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,QAAQ,SAAI,OAAO,SAAI,UAAY,EACtC,cAAM,OAAA,aAAa,CAAC,uBAAuB,CAAC,OAAO,EAAE,UAAU,CAAC,EAA1D,CAA0D,CAAC,CAAC;QAEtE,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,aAAa,CAAC,SAAS,CACnB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,aAAa,CAAC,CAAC;QAEnB,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,uCAAc,GAAxB,UAAyB,OAAgB;QACvC,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC5C,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,WAAW,SAAI,OAAO,SAAI,UAAY,EACzC,cAAM,OAAA,aAAa,CAAC,6BAA6B,CAAC,OAAO,EAAE,UAAU,CAAC,EAAhE,CAAgE,CAAC,CAAC;QAE5E,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,aAAa,CAAC,SAAS,CACnB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,aAAa,CAAC,CAAC;QAEnB,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,uCAAc,GAAxB,UAAyB,OAAgB;QACvC,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC5C,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,WAAW,SAAI,OAAO,SAAI,UAAY,EACzC,cAAM,OAAA,aAAa,CAAC,6BAA6B,CAAC,OAAO,EAAE,UAAU,CAAC,EAAhE,CAAgE,CAAC,CAAC;QAE5E,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,aAAa,CAAC,SAAS,CACnB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,aAAa,CAAC,CAAC;QAEnB,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,6CAAoB,GAA9B,UAA+B,EAAW,EAAE,EAAW;QAErD,IAAM,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;QAChD,IAAM,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;QAChD,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAC1D,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;YAC/C,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;QAED,IAAM,cAAc,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;QACvC,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,kBAAkB,SAAI,OAAO,SAAI,UAAY,EAChD,cAAM,OAAA,gBAAgB,CAAC,mCAAmC,CACtD,OAAO,EAAE,UAAU,CAAC,EADlB,CACkB,CAAC,CAAC;QAE9B,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,gBAAgB,CAAC,YAAY,CACzB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,OAAO,EAC9D,UAAU,EAAE,aAAa,CAAC,CAAC;QAE/B,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACd,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,qCAAY,GAAtB,UAAuB,OAAgB,EAAE,CAAS;QAEhD,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC5C,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,QAAQ,SAAI,OAAO,SAAI,UAAY,EACtC,cAAM,OAAA,UAAU,CAAC,0BAA0B,CAAC,OAAO,EAAE,UAAU,CAAC,EAA1D,CAA0D,CAAC,CAAC;QAEtE,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,UAAU,CAAC,MAAM,CACb,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,aAAa,CAAC,CAAC;QAEnB,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,oCAAW,GAArB,UAAsB,OAAgB;QACpC,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC5C,IAAA,2BAAO,EAAE,8BAAU,CAAmB;QAE7C,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,QAAQ,SAAI,OAAO,SAAI,UAAY,EACtC,cAAM,OAAA,UAAU,CAAC,0BAA0B,CAAC,OAAO,EAAE,UAAU,CAAC,EAA1D,CAA0D,CAAC,CAAC;QAEtE,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjE,UAAU,CAAC,MAAM,CACb,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,aAAa,CAAC,CAAC;QAEnB,MAAM,CAAC,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;IAC9C,CAAC;IAES,uCAAc,GAAxB,UAA4C,CAAI,EAAE,CAAI;QACpD,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,qDAA4B,GAAtC,UAA0D,CAAS,EAAE,CAAI;QAEvE,MAAM,CAAC,IAAI,CAAC,YAAY,CACb,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IAC9E,CAAC;IAES,qDAA4B,GAAtC,UAA0D,CAAI,EAAE,CAAS;QAEvE,MAAM,CAAC,IAAI,CAAC,YAAY,CACb,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IAC9E,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI,EAAE,CAAI;QACjD,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,oCAAW,GAArB,UAAyC,CAAI,EAAE,CAAI;QACjD,MAAM,CAAC,IAAI,CAAC,YAAY,CACpB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,8BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,8BAAW,CAAC,MAAM,CAAM,CAAC;IACvE,CAAC;IAES,0CAAiB,GAA3B,UAA4B,OAAgB;QACpC,IAAA,gCAAmD,EAAlD,eAAO,EAAE,kBAAU,CAAgC;QAE1D,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAC/B,cAAc,SAAI,OAAO,SAAI,UAAY,EAC5C,cAAM,OAAA,aAAa,CAAC,uBAAuB,CAAC,OAAO,EAAE,UAAU,CAAC,EAA1D,CAA0D,CAAC,CAAC;QAEtE,IAAM,MAAM,GACR,IAAI,gBAAM,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC;QAEtE,aAAa,CAAC,SAAS,CACnB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,UAAU,EAC9D,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;QAEzB,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,QAAQ,EAAE,cAAM,OAAA,OAAO,CAAC,uBAAuB,EAAE,EAAjC,CAAiC,CAAC,CAAC;QAEvD,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,OAAO,CAAC,GAAG,CACP,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,QAAQ,EAAE,cAAM,OAAA,OAAO,CAAC,uBAAuB,EAAE,EAAjC,CAAiC,CAAC,CAAC;QAEvD,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QACzE,OAAO,CAAC,GAAG,CACP,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,SAAS,EAAE,cAAM,OAAA,QAAQ,CAAC,uBAAuB,EAAE,EAAlC,CAAkC,CAAC,CAAC;QAEzD,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,IAAI,CACT,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,wCAAe,GAAzB,UAA6C,OAAU;QACrD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,YAAY,EAAE,cAAM,OAAA,WAAW,CAAC,8BAA8B,EAAE,EAA5C,CAA4C,CAAC,CAAC;QAEtE,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,WAAW,CAAC,OAAO,CACf,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,SAAS,EAAE,cAAM,OAAA,QAAQ,CAAC,2BAA2B,EAAE,EAAtC,CAAsC,CAAC,CAAC;QAE7D,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,IAAI,CACT,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,oCAAW,GAArB,UAAyC,OAAU;QACjD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,QAAQ,EAAE,cAAM,OAAA,QAAQ,CAAC,0BAA0B,EAAE,EAArC,CAAqC,CAAC,CAAC;QAE3D,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,GAAG,CACR,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,qCAAY,GAAtB,UAA0C,OAAU;QAClD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,SAAS,EAAE,cAAM,OAAA,QAAQ,CAAC,uBAAuB,EAAE,EAAlC,CAAkC,CAAC,CAAC;QAEzD,IAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,IAAI,CACT,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,EAC5D,cAAc,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAEtC,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,OAAO,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;IAC/D,CAAC;IAES,uCAAc,GAAxB,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,MAAc,EAClE,OAAe;QACjB,IAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,IAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACpC,IAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACrC,IAAM,OAAO,GAAG;YACd,WAAW,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,IAAI,IAAI;SACrE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE;YAC9C,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CACnC,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,IAAI,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;QAEH,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAM,SAAS,GACX,SAAS,CAAC,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QACzE,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QAIlE,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAC7D,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAClD,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAM,eAAe,GAAG,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;YAC/D,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;gBACrD,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBACnD,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAED,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACtD,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACpE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,QAAQ,CAAC,QAAQ,CACb,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,OAAO,CAAC,UAAU,EAAE,EACzD,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC,UAAU,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAE5E,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,IAAI,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YAC/B,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,WAAW,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IACzE,CAAC;IAES,+CAAsB,GAAhC,UACI,CAAU,EAAE,EAAW,EAAE,OAAgB,EAAE,MAAc,EACzD,GAAW;QACb,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACpC,IAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACrC,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAM,SAAS,GACX,SAAS,CAAC,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;QACrE,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAI5D,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAC7D,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAClD,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,EAAE,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACxD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;YACxC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAM,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5D,IAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAClC,IAAM,EAAE,GAAG,IAAI,CAAC,uBAAuB,CACnC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAgB,MAAM,EAAE,GAAG,CAAC,CAAC;QAElD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QACD,MAAM,CAAC,EAAC,EAAE,IAAA,EAAE,EAAE,IAAA,EAAE,EAAE,IAAA,EAAC,CAAC;IACtB,CAAC;IAES,gDAAuB,GAAjC,UACI,CAAU,EAAE,OAAgB,EAAE,MAAoB,EAAE,UAAkB,EACtE,OAAe;QACjB,IAAM,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxC,IAAM,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACzC,IAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAEnC,IAAM,OAAO,GAAG;YACd,qBAAqB,EAAE,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU;YACrE,OAAO,EAAE,MAAM,IAAI,IAAI;SACxB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE;YAC9C,MAAM,CAAC,iBAAiB,CAAC,oCAAoC,CACzD,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EACvD,MAAM,IAAI,IAAI,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;QAEH,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAM,SAAS,GAAG,SAAS,CAAC,sBAAsB,CAC9C,cAAc,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;QAChD,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;QAIrE,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAC7D,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAClD,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAM,kBAAkB,GAAG,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;YAClE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;gBACxD,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBACnD,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAGD,IAAM,SAAS,GACX,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QACrE,IAAM,GAAG,GAAG,SAAS,GAAG,CAAC,GAAG,OAAO,CAAC;QACpC,IAAM,WAAW,GAAG,SAAS,CAAC,oBAAoB,CAC9C,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,EAAE,SAAS,EACxD,cAAc,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAC5B,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACpE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,iBAAiB,CAAC,aAAa,CAC3B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,OAAO,CAAC,UAAU,EAAE,EACzD,MAAM,IAAI,IAAI,GAAG,MAAM,CAAC,UAAU,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAE5E,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,MAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,WAAW,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IACzE,CAAC;IAED,yCAAgB,GAAhB,UACI,CAAU,EAAE,EAAW,EAAE,KAAa,EAAE,MAAc,EACtD,OAAe;QACjB,IAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAM,WAAW,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChC,IAAM,OAAO,GAAG;YACd,gBAAgB,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO;SAC/D,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE;YAC9C,MAAM,CAAC,iBAAiB,CAAC,iCAAiC,CACtD,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAM,MAAM,GAAG,SAAS,CAAC,oBAAoB,CACzC,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAClD,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAI1D,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,EAAE,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACxD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;YACxC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAM,cAAc,GAChB,SAAS,CAAC,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;QACrE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,iBAAiB,CAAC,UAAU,CACxB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAC/D,cAAc,CAAC,CAAC;QAEpB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QACD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,IAAM,YAAY,GACd,SAAS,CAAC,qBAAqB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;QACpE,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,YAAY,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC1E,CAAC;IAED,sCAAa,GAAb,UAAc,EAAW;QACvB,IAAM,WAAW,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChC,IAAM,OAAO,GAAG,CAAC,gBAAgB,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvD,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE;YAC9C,MAAM,CAAC,iBAAiB,CAAC,8BAA8B,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QACH,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAI5D,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAM,eAAe,GAAG,EAAE,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACxD,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;YACxC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACpE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,iBAAiB,CAAC,OAAO,CACrB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAErE,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,CAAC,WAAW,CAAC,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC3E,CAAC;IAEO,6BAAI,GAAZ,UACI,OAAqB,EAAE,CAAU,EAAE,KAAa,EAAE,MAAc,EAChE,GAAW;QACb,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAI3D,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAM,WAAW,GACb,SAAS,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5E,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACpE,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,QAAQ,CAAC,UAAU,CACf,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;QAExE,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,WAAW,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC7E,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,IAAM,cAAc,GAChB,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3D,IAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE;YAC5D,MAAM,CAAC,YAAY,CAAC,8BAA8B,CAC9C,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1D,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,IAAM,cAAc,GAChB,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3D,IAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE;YAC5D,MAAM,CAAC,YAAY,CAAC,8BAA8B,CAC9C,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1D,CAAC;IAES,wCAAe,GAAzB,UACI,CAAU,EAAE,KAAa,EAAE,MAAc,EAAE,GAAW;QACxD,IAAM,cAAc,GAChB,CAAC,aAAa,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3D,IAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE;YAC5D,MAAM,CAAC,YAAY,CAAC,8BAA8B,CAC9C,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1D,CAAC;IAES,gDAAuB,GAAjC,UACI,EAAW,EAAE,CAAU,EAAE,KAAa,EAAE,UAAkB,EAC1D,OAAe;QACjB,IAAM,uBAAuB,GAAG;YAC9B,uBAAuB,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO;SAC7D,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,uBAAuB,GACzB,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,EAAE;YAC9C,MAAM,CAAC,YAAY,CAAC,uCAAuC,CACvD,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEP,IAAM,kBAAkB,GAAG,SAAS,CAAC,oBAAoB,CACrD,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QACrD,IAAM,qBAAqB,GACvB,SAAS,CAAC,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;QACxD,IAAM,yBAAyB,GAC3B,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;QAG9D,IAAM,SAAS,GAAG,SAAS,CAAC,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAM,eAAe,GAAG,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;YAClD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,YAAY,CAAC,aAAa,CACtB,IAAI,CAAC,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC,UAAU,EAAE,EACnD,yBAAyB,EAAE,qBAAqB,CAAC,CAAC;QAEtD,IAAM,sBAAsB,GAAG;YAC7B,sBAAsB,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO;SAC7D,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,EAAE;YAC7D,MAAM,CAAC,qBAAqB,CAAC,gCAAgC,CACzD,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAM,UAAU,GAAG,SAAS,CAAC,qBAAqB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAI7D,IAAM,gBAAgB,GAAG,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC1D,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;YACpD,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,UAAU,CAAC,CAAC;YACzC,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;QAED,IAAM,WAAW,GACb,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QACvE,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;QAChC,IAAM,cAAc,GAAG,SAAS,CAAC,oBAAoB,CACjD,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EACpE,GAAG,CAAC,CAAC;QACT,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;QACvE,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAErE,qBAAqB,CAAC,eAAe,CACjC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,yBAAyB,EAC/D,SAAS,EAAE,cAAc,CAAC,CAAC;QAE/B,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACd,EAAE,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,cAAc,CAC9B,yBAAyB,EAAE,qBAAqB,CAAC,CAAC;QAEtD,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,cAAc,EAAE,EAAC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC5E,CAAC;IAES,iDAAwB,GAAlC,UACI,CAAU,EAAE,UAA4B,EACxC,YAAqB;QACvB,IAAM,UAAU,GACZ,CAAC,oBAAoB,EAAE,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAExE,IAAM,WAAW,GACb,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,IAAM,cAAc,GAAG,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QAEpE,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,UAAU,EACV,cAAM,OAAA,mBAAmB,CAAC,uBAAuB,CAC7C,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,CAAC,EADhC,CACgC,CAAC,CAAC;QAE5C,IAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAEzE,mBAAmB,CAAC,cAAc,CAC9B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;QAExE,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,WAAW,EAAE,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;IAC7E,CAAC;IAEO,0CAAiB,GAAzB,UAA0B,UAAkB,EAAE,eAA6B;QAEzE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACvC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC;gBACzB,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAEO,qCAAY,GAApB,UACI,CAAU,EAAE,CAAU,EAAE,WAAqB,EAC7C,QAAsC,EACtC,MAAkC,EAClC,QAAsC;QACxC,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,IAAM,YAAY,GAAG,wBAAiB,CAAC,OAAO,CAAC;QAC/C,IAAI,YAAY,GAAG,wBAAiB,CAAC,OAAO,CAAC;QAE7C,IAAI,gBAAkC,CAAC;QAEvC,EAAE,CAAC,CAAC,QAAQ,KAAK,8BAAW,CAAC,MAAM,IAAI,QAAQ,KAAK,8BAAW,CAAC,MAAM,CAAC,CAAC,CAAC;YACvE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YAEzC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBAEd,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;YAC7C,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBAErB,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;YAC7C,CAAC;YAED,IAAM,WAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;YACxC,IAAM,WAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;YACxC,gBAAgB,GAAG,WAAS,CAAC;YAE7B,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;gBAGjB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,WAAS,EAAE,WAAS,CAAC,CAAC,CAAC,CAAC;oBAC5C,YAAY,GAAG,wBAAiB,CAAC,UAAU,CAAC;oBAC5C,gBAAgB,GAAG,CAAC,WAAS,CAAC,CAAC,CAAC,EAAE,WAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClD,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,WAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;gBACnD,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,WAAS,CAAC,CAAC;gBACtC,YAAY,GAAG,wBAAiB,CAAC,OAAO,CAAC;gBACzC,gBAAgB,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;gBACzC,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,gBAAgB,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAC3C,CAAC;QAED,IAAM,SAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QACxC,IAAM,SAAS,GAAG,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAExC,IAAM,UAAU,GAAG;YACjB,oBAAoB,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ;YAC9D,YAAY;SACb,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,IAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAClC,UAAU,EACV,cAAM,OAAA,gBAAgB,CAAC,uBAAuB,CAC1C,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,EADrD,CACqD,CAAC,CAAC;QAEjE,IAAM,kBAAkB,GAAqB;YAC3C,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;SAC5C,CAAC;QAEF,IAAM,aAAa,GACf,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;QAE3D,gBAAgB,CAAC,YAAY,CACzB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,UAAU,EAAE,EAC9D,SAAS,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;QAElD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YACb,CAAC,CAAC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,CAAC,iBAAO,CAAC,IAAI,CACf,WAAW,EACX,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,kBAAkB,EAAC,CAAC,CAAC;IACpE,CAAC;IAEO,yCAAgB,GAAxB,UAAyB,CAAU,EAAE,CAAU;QAC7C,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QACzC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAEd,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAC7C,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAErB,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,0CAAiB,GAAjB;QACE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,gCAAO,GAAP;QACE,GAAG,CAAC,CAAC,IAAM,UAAU,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YAC3C,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBACjD,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QAE9B,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;IACH,qBAAC;AAAD,CA3qCA,AA2qCC,CA3qCmC,kBAAW,GA2qC9C;AA3qCY,wCAAc;;;;;;;;;;;;;;;AC5F3B,8BAAgC;AAIhC,+CAAiD;AAKtC,QAAA,KAAK,GAAiB,IAAK,CAAC;AAE5B,QAAA,eAAe,GAAmB,IAAK,CAAC;AAWnD,uBACI,KAAmB,EAAE,cAA8B;IACrD,aAAK,GAAG,KAAK,CAAC;IACd,uBAAe,GAAG,cAAc,CAAC;AACnC,CAAC;AAJD,sCAIC;AAED;IACE,EAAE,CAAC,CAAC,aAAK,IAAI,IAAI,IAAI,uBAAe,IAAI,IAAI,CAAC,CAAC,CAAC;QAC7C,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;AACH,CAAC;AAED;IAcE,iBAAsB,KAAe,EAAE,IAAiB;QAEtD,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,EAC3C,8CAA8C,CAAC,CAAC;QAEpD,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,OAAO,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,EACrD,0DAA0D,CAAC,CAAC;QAEhE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAEtC,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAChC,iCAAiC,GAAG,IAAI,CAAC,IAAI,GAAG,oBAAoB;gBAChE,qBAAqB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAE9B,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACZ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QACpB,CAAC;QAAC,IAAI,CAAC,CAAC;YAGN,IAAI,CAAC,OAAO,GAAG,IAAI,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YAC5C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAClC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC;IACH,CAAC;IAGM,aAAK,GAAZ,UAAgC,KAAe;QAC7C,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3D,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,KAAK,EAAE,EAAC,MAAM,QAAA,EAAC,CAAC,CAAC;IAC1C,CAAC;IAIM,iBAAS,GAAhB,UAAoC,OAAU;QAC5C,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAM,CAAC;IAC3C,CAAC;IAGM,YAAI,GAAX,UAA+B,OAAU;QACvC,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;QACnC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,IAAI,YAAY,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IAC5E,CAAC;IAMM,YAAI,GAAX,UAA+B,KAAe,EAAE,IAAiB;QAC/D,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;YACrB,KAAK,CAAC;gBACJ,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAM,CAAC;YAC/B,KAAK,CAAC;gBAEJ,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAQ,CAAC;YAClC,KAAK,CAAC;gBAEJ,MAAM,CAAC,IAAI,OAAO,CAAC,KAAyB,EAAE,IAAI,CAAQ,CAAC;YAC7D,KAAK,CAAC;gBAEJ,MAAM,CAAC,IAAI,OAAO,CAAC,KAAiC,EAAE,IAAI,CAAQ,CAAC;YACrE,KAAK,CAAC;gBACJ,MAAM,CAAC,IAAI,OAAO,CAEP,KAAyC,EAAE,IAAI,CAAQ,CAAC;YACrE;gBAEE,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,IAAI,CAAQ,CAAC;QAC3C,CAAC;IACH,CAAC;IAGD,yBAAO,GAAP,UAA2B,QAAkB;QAC3C,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;YAG3C,MAAM,CAAC,IAAW,CAAC;QACrB,CAAC;QAED,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAC1C,gEAAgE,CAAC,CAAC;QAEtE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED,0BAAQ,GAAR;QACE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,qCAAqC,CAAC,CAAC;QACpE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAS,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,sBAAI,GAAJ;QACE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED,sBAAI,GAAJ,UAAK,IAAY,EAAE,OAAe;QAChC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,sBAAI,GAAJ,UAAK,IAAY,EAAE,OAAe,EAAE,KAAa;QAC/C,MAAM,CAAC,IAAI,CAAC,OAAO,CAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;IACvD,CAAC;IAED,sBAAI,GAAJ,UAAK,IAAY,EAAE,OAAe,EAAE,KAAa,EAAE,MAAc;QAC/D,MAAM,CAAC,IAAI,CAAC,OAAO,CAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,sBAAI,yBAAI;aAAR;YACE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3B,CAAC;;;OAAA;IAED,qBAAG,GAAH;QAAI,cAAiB;aAAjB,UAAiB,EAAjB,qBAAiB,EAAjB,IAAiB;YAAjB,yBAAiB;;QACnB,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACzC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa;QAAE,cAAiB;aAAjB,UAAiB,EAAjB,qBAAiB,EAAjB,IAAiB;YAAjB,6BAAiB;;QAClC,IAAI,CAAC,GAAG,OAAR,IAAI,GAAK,IAAI,CAAC,GAAG,OAAR,IAAI,EAAQ,IAAI,IAAI,KAAK,SAAK,IAAI,GAAE;IAC/C,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa;QAAE,cAAiB;aAAjB,UAAiB,EAAjB,qBAAiB,EAAjB,IAAiB;YAAjB,6BAAiB;;QAClC,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACzC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IAClC,CAAC;IAED,4BAAU,GAAV,UAAW,IAAc;QACvB,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACzC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,KAAK,CAAC;IACf,CAAC;IAED,4BAAU,GAAV,UAAW,KAAa;QACtB,IAAM,IAAI,GAAa,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9C,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC;IACd,CAAC;IAED,sBAAI,GAAJ,UAAK,KAAa;QAChB,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,yBAAO,GAAP;QACE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,2BAAS,GAAT;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;YAC7B,wBAAwB,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,aAAK,CAAC,yBAAyB,CAC9C,IAAI,CAAC,IAAI,CAAC,OAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,cAAe,CAAC,CAAC,CAAC,EAChD,IAAI,CAAC,IAAI,CAAC,cAAe,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC1B,CAAC;IAEO,6BAAW,GAAnB,UAAoB,iBAAoC;QACtD,wBAAwB,EAAE,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,+BAA+B,CACjE,aAAK,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,OAAO;YACb,uBAAe,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAE7D,aAAK,CAAC,qBAAqB,CACvB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAC9C,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAO,CAAC,CAAC;QAEpD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAK,CAAC;IAC3B,CAAC;IAED,4BAAU,GAAV,UAAW,gBAAmC;QAC5C,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAQ,CAAC;IAC5B,CAAC;IAED,mCAAiB,GAAjB,UAAkB,gBAAmC;QACnD,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAe,CAAC;IACnC,CAAC;IAED,yBAAO,GAAP;QACE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAK,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,IAAK,CAAC;QACnB,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;IAEO,gCAAc,GAAtB;QACE,wBAAwB,EAAE,CAAC;QAC3B,uBAAe,CAAC,cAAc,CAC1B,IAAI,CAAC,IAAI,CAAC,OAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,cAAe,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,IAAK,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,IAAK,CAAC;IACnC,CAAC;IAED,uBAAK,GAAL;QACE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC;IACnC,CAAC;IAED,wBAAM,GAAN,UAAO,CAAU;QACf,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;IACxD,CAAC;IAEM,YAAI,GAAX,UAA+B,KAAe,EAAE,YAA0B;QAExE,IAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACvC,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;QACtC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,MAAM,CAAC,CAAC,CAAC,GAAG,YAAY,EAAE,CAAC;QAC7B,CAAC;QAED,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,KAAK,EAAE,EAAC,MAAM,QAAA,EAAC,CAAC,CAAC;IAC1C,CAAC;IAEM,kBAAU,GAAjB,UAAqC,KAAe,EAAE,IAAQ,EAAE,MAAU;QAApB,qBAAA,EAAA,QAAQ;QAAE,uBAAA,EAAA,UAAU;QACxE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,KAAK,EAAE,cAAM,OAAA,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,EAA5B,CAA4B,CAAC,CAAC;IACpE,CAAC;IAEM,2BAAmB,GAA1B,UACI,KAAe,EAAE,IAAQ,EAAE,MAAU;QAApB,qBAAA,EAAA,QAAQ;QAAE,uBAAA,EAAA,UAAU;QACvC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,KAAK,EAAE,cAAM,OAAA,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAlC,CAAkC,CAAC,CAAC;IAC1E,CAAC;IAEM,mBAAW,GAAlB,UAAsC,KAAe,EAAE,CAAS,EAAE,CAAS;QACzE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAI,KAAK,EAAE,cAAM,OAAA,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAtB,CAAsB,CAAC,CAAC;IAC9D,CAAC;IACH,cAAC;AAAD,CA5QA,AA4QC,IAAA;AA5QY,0BAAO;AA8QpB;IAA4B,0BAAO;IACjC,gBAAY,IAAiB;QAA7B,iBAKC;QAJC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/B,CAAC;QACD,QAAA,kBAAM,EAAE,EAAE,IAAI,CAAC,SAAC;;IAClB,CAAC;IAEM,UAAG,GAAV,UAAW,KAAa;QACtB,MAAM,CAAC,IAAI,MAAM,CAAC,EAAC,MAAM,EAAE,IAAI,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,EAAC,CAAC,CAAC;IACzD,CAAC;IAOD,oBAAG,GAAH;QACE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED,oBAAG,GAAH,UAAI,KAAa;QACf,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED,oBAAG,GAAH,UAAI,KAAa;QACf,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;IAC/B,CAAC;IACH,aAAC;AAAD,CA5BA,AA4BC,CA5B2B,OAAO;AAY1B,WAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACrB,UAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACpB,UAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACpB,cAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAfrB,wBAAM;AA8BnB;IAA6B,2BAAO;IAGlC,iBAAY,IAAiB;QAA7B,iBAKC;QAJC,IAAM,KAAK,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;YAC/B,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;YACpB,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,cAAe,CAAC,CAAC,CAAC;QAC/C,QAAA,kBAAM,KAAK,EAAE,IAAI,CAAC,SAAC;;IACrB,CAAC;IAEM,WAAG,GAAV,UAAW,MAA6B;QACtC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC;YACtC,IAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,CAAC,MAAM,CACP,aAAa,CAAC,MAAM,KAAK,CAAC,EAC1B,iDAA+C,aAAa,SAAM;gBAC9D,oBAAoB,CAAC,CAAC;QAChC,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAC,EAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IACrD,CAAC;IAED,qBAAG,GAAH,UAAI,CAAS;QACX,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS;QAC1B,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS;QAC1B,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;IAC/B,CAAC;IAED,4BAAU,GAAV,UAAW,GAAa;QACtB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB,CAAC;IAED,4BAAU,GAAV,UAAW,KAAa;QACtB,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAEM,aAAK,GAAZ,UAAa,KAAe;QAC1B,MAAM,CAAC,OAAO,CAAC,KAAK,CAAU,KAAK,CAAC,CAAC;IACvC,CAAC;IACH,cAAC;AAAD,CA5CA,AA4CC,CA5C4B,OAAO,GA4CnC;AA5CY,0BAAO;AA8CpB;IAA6B,2BAAO;IAKlC,iBAAY,KAAuB,EAAE,IAAiB;QAAtD,iBAIC;QAHC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,6BAA6B,CAAC,CAAC;QAC/D,QAAA,kBAAM,KAAK,EAAE,IAAI,CAAC,SAAC;QACnB,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;IACjC,CAAC;IAEM,WAAG,GAAV,UACI,KAAuB,EAAE,MAAwC;QACnE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC;YACtC,IAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC9C,EAAE,CAAC,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC7B,IAAI,CAAC,iBAAiB,CAClB,KAAK,EAAE,aAAa,EACpB,mDAAmD;qBAC5C,aAAa,wCAAqC,CAAA;qBAClD,KAAK,OAAI,CAAA,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IAC5D,CAAC;IAED,qBAAG,GAAH,UAAI,CAAS,EAAE,CAAS;QACtB,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS;QACrC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;IACjD,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS;QACrC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC;IAClD,CAAC;IAED,4BAAU,GAAV,UAAW,IAAsB;QAC/B,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,4BAAU,GAAV,UAAW,KAAa;QACtB,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAClE,CAAC;IAEM,aAAK,GAAZ,UAAa,KAAuB;QAClC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAU,KAAK,CAAC,CAAC;IACvC,CAAC;IACH,cAAC;AAAD,CAjDA,AAiDC,CAjD4B,OAAO,GAiDnC;AAjDY,0BAAO;AAmDpB;IAA6B,2BAAO;IAKlC,iBAAY,KAA+B,EAAE,IAAiB;QAA9D,iBAKC;QAJC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,6BAA6B,CAAC,CAAC;QAC/D,QAAA,kBAAM,KAAK,EAAE,IAAI,CAAC,SAAC;QACnB,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;IACjC,CAAC;IAEM,WAAG,GAAV,UACI,KAA+B,EAC/B,MAA0C;QAC5C,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC;YACtC,IAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC9C,EAAE,CAAC,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC7B,IAAI,CAAC,iBAAiB,CAClB,KAAK,EAAE,aAAa,EACpB,mDAAmD;qBAC5C,aAAa,wCAAqC,CAAA;qBAClD,KAAK,OAAI,CAAA,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IAC5D,CAAC;IAED,qBAAG,GAAH,UAAI,CAAS,EAAE,CAAS,EAAE,CAAS;QACjC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAChD,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;IACpE,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAChD,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC;IACrE,CAAC;IAED,4BAAU,GAAV,UAAW,IAA8B;QACvC,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,4BAAU,GAAV,UAAW,KAAa;QACtB,IAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,aAAK,GAAZ,UAAa,KAA+B;QAC1C,MAAM,CAAC,OAAO,CAAC,KAAK,CAAU,KAAK,CAAC,CAAC;IACvC,CAAC;IACH,cAAC;AAAD,CArDA,AAqDC,CArD4B,OAAO,GAqDnC;AArDY,0BAAO;AAuDpB;IAA6B,2BAAO;IAMlC,iBAAY,KAAuC,EAAE,IAAiB;QAAtE,iBAMC;QALC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,6BAA6B,CAAC,CAAC;QAC/D,QAAA,kBAAM,KAAK,EAAE,IAAI,CAAC,SAAC;QACnB,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;IACjC,CAAC;IAEM,WAAG,GAAV,UACI,KAAuC,EACvC,MAA4C;QAC9C,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC;YACtC,IAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC9C,EAAE,CAAC,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC7B,IAAI,CAAC,iBAAiB,CAClB,KAAK,EAAE,aAAa,EACpB,mDAAmD;qBAC5C,aAAa,wCAAqC,CAAA;qBAClD,KAAK,OAAI,CAAA,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IAC5D,CAAC;IAED,qBAAG,GAAH,UAAI,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAC5C,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAClB,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAC3D,IAAI,CAAC,SAAS,EAAE,CACX,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;IAC3E,CAAC;IAED,qBAAG,GAAH,UAAI,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAC3D,IAAI,CAAC,SAAS,EAAE,CACX,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC;IAC5E,CAAC;IAED,4BAAU,GAAV,UAAW,IAAsC;QAC/C,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC;YAClD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC;IAED,4BAAU,GAAV,UAAW,KAAa;QACtB,IAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QAC1B,IAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IACxE,CAAC;IAEM,aAAK,GAAZ,UAAa,KAAuC;QAClD,MAAM,CAAC,OAAO,CAAC,KAAK,CAAU,KAAK,CAAC,CAAC;IACvC,CAAC;IACH,cAAC;AAAD,CA7DA,AA6DC,CA7D4B,OAAO,GA6DnC;AA7DY,0BAAO;AAiEpB,sBAAsB,CAAY;IAChC,MAAM,CAAC,CAAC,CAAC,YAAY,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7E,CAAC;;;;;ACziBD,iDAA6C;AAE7C;IACE,MAAM,CAAC,wmBAiBH,CAAC;AACP,CAAC;AAnBD,0DAmBC;AAED,2BACI,KAAmB,EAAE,wBAAsC,EAC3D,CAAe,EAAE,CAAe,EAAE,IAAY,EAAE,OAAe,EAC/D,OAAqB,EAAE,OAAqB,EAAE,MAAoB;IACpE,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,KAAK,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC;IAC3C,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;IACzD,KAAK,CAAC,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;IACzD,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAXD,8CAWC;AAED,yCACI,CAAe,EAAE,CAAe,EAAE,IAAY,EAAE,OAAe,EAC/D,OAAe,EAAE,OAAe;IAClC,IAAM,KAAK,GAAG,IAAI,4BAAY,EAAE,CAAC;IACjC,IAAM,OAAO,GAAiB,KAAK,CAAC,aAAa,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAE7E,IAAM,IAAI,GAAG,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACtD,IAAM,IAAI,GAAG,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACtD,IAAM,UAAU,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,IAAM,UAAU,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,IAAM,SAAS,GAAG,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAE3D,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACpD,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACpD,KAAK,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3E,KAAK,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE3E,iBAAiB,CACb,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EACjE,SAAS,CAAC,CAAC;IAEf,IAAM,MAAM,GAAG,KAAK,CAAC,yBAAyB,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAEzE,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAChC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAChC,KAAK,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;IACrC,KAAK,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACtC,KAAK,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACtC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAEhB,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAhCD,0EAgCC;;;;;ACpED,gCAA0C;AAE1C,6CAA+C;AAK/C,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,iDAAM,CAAA;IACN,iDAAM,CAAA;AACR,CAAC,EAHW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAGtB;AAED,iCACI,KAAkB,EAAE,YAA+B,EAAE,EAAa,EAClE,KAAkB,EAAE,YAA+B;IACrD,IAAM,GAAG,GAAG,sBAAsB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACxD,IAAM,GAAG,GAAG,sBAAsB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACxD,IAAM,QAAQ,GAAG,2BAAyB,EAAE,kBAAe,CAAC;IAC5D,MAAM,CAAC,YAAY,CAAC,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AAClE,CAAC;AAPD,0DAOC;AAED,gCACI,OAAoB,EAAE,WAA8B;IACtD,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;QAChB,KAAK,WAAW,CAAC,MAAM;YACrB,MAAM,CAAC,UAAU;gBACb,CAAC,WAAW,KAAK,wBAAiB,CAAC,OAAO,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC;QAClE,KAAK,WAAW,CAAC,MAAM;YACrB,MAAM,CAAC,gBAAgB,CAAC;QAC1B;YACE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC;AAED,sBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,YAA8B,EAAE,CAAe,EAC/C,YAA8B,EAAE,MAAoB,EACpD,iBAAmC;IACrC,MAAM,CAAC,YAAY,CAAC,QAAQ,CACxB,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,MAAM,EACxD,iBAAiB,CAAC,CAAC;AACzB,CAAC;AARD,oCAQC;AAED,wCACI,CAAS,EAAE,CAAe,EAAE,MAAwB,EACpD,YAAwC;IAAxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,wBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EACtE,YAAY,CAAC,CAAC;IAClB,MAAM,CAAC,YAAY,CAAC,sBAAsB,CACtC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AARD,wEAQC;AAED,yCACI,CAAe,EAAE,MAAwB,EAAE,CAAS,EACpD,YAAwC;IAAxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EACzD,wBAAiB,CAAC,OAAO,CAAC,CAAC;IAC/B,MAAM,CAAC,YAAY,CAAC,sBAAsB,CACtC,CAAC,EAAE,MAAM,EAAE,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AARD,0EAQC;AAED,yCACI,CAAS,EAAE,CAAe,EAAE,MAAwB,EACpD,YAAwC;IAAxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,wBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EACtE,YAAY,CAAC,CAAC;IAClB,MAAM,CAAC,YAAY,CAAC,sBAAsB,CACtC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AARD,0EAQC;AAED,yCACI,CAAS,EAAE,CAAe,EAAE,MAAwB,EACpD,YAAwC;IAAxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,wBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EACtE,YAAY,CAAC,CAAC;IAClB,MAAM,CAAC,YAAY,CAAC,sBAAsB,CACtC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AARD,0EAQC;AAED,yCACI,CAAe,EAAE,CAAe,EAAE,KAAuB,EACzD,YAAwC,EACxC,YAAwC;IADxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IACxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC7E,MAAM,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AACtE,CAAC;AAPD,0EAOC;AAED,wCACI,CAAe,EAAE,CAAe,EAAE,KAAuB,EACzD,YAAwC,EACxC,YAAwC;IADxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IACxC,6BAAA,EAAA,eAAe,wBAAiB,CAAC,OAAO;IAC1C,IAAM,GAAG,GAAG,uBAAuB,CAC/B,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC7E,MAAM,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AACtE,CAAC;AAPD,wEAOC;;;;;ACpGD,+CAAiD;AAIjD;IACE,MAAM,CAAC,0HAIkB,CAAC;AAC5B,CAAC;AAED;IACE,MAAM,CAAC,kXAaH,CAAC;AACP,CAAC;AAED,6CACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC;QACL,+BAA+B,EAAE;QACjC,aAAa,CAAC,mCAAmC,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC;QACrE,2BAA2B,EAAE;KAC9B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAPD,kFAOC;AAED,sBACI,KAAmB,EAAE,gBAA8B,EAAE,CAAe,EACpE,CAAe,EAAE,OAAe,EAAE,OAAe,EAAE,MAAoB;IACzE,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACnC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,oCAQC;;;;;AC7CD,2CAAgD;AAEhD;IACE,MAAM,CAAC,0FAGkB,CAAC;AAC5B,CAAC;AALD,0EAKC;AAED;IACE,MAAM,CAAC,wFAGH,CAAC;AACP,CAAC;AAED,0CACI,IAAY,EAAE,OAAe,EAAE,MAAc;IAC/C,MAAM,CAAC;QACL,+BAA+B,EAAE;QACjC,mCAAmC,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;QAC1D,2BAA2B,EAAE;KAC9B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,uCACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,gCAAgC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;AAC9D,CAAC;AAHD,sEAGC;AAED,uCACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,gCAAgC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;AAC9D,CAAC;AAHD,sEAGC;AAED,6CACI,MAAc,EAAE,IAAY,EAAE,OAAe;IAC/C,MAAM,CAAC,mCACqB,OAAO,YAAO,IAAI,6DAG1C,+BAAkB,wdAcF,MAAM,uKAQzB,CAAC;AACJ,CAAC;AA7BD,kFA6BC;AAED,mBACI,KAAmB,EAAE,aAA2B,EAAE,CAAe,EACjE,QAAgB,EAAE,QAAgB,EAAE,MAAoB;IAC1D,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAChC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAPD,8BAOC;;;;;ACzED,qCAAuC;AAEvC,wCACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW;IACb,MAAM,CAAC,QAAQ,CAAC,iCAAiC,CAC7C,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACnD,CAAC;AALD,wEAKC;AAED,iBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,MAAoB,EAAE,iBAAmC;IAC3D,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC;AACpE,CAAC;AAJD,0BAIC;;;;;ACZD,iCACI,WAA6B,EAAE,cAAgC,EAC/D,kBAAoC,EACpC,gBAAuC,EACvC,eAAuC,EAAE,eAAuB;IAAvB,gCAAA,EAAA,uBAAuB;IAClE,IAAI,oBAAoB,GAAG,EAAE,CAAC;IAC9B,IAAI,gCAAgC,GAAG,EAAE,CAAC;IAC1C,IAAI,mBAAmB,GAAG,EAAE,CAAC;IAC7B,IAAI,eAAe,GAAG,EAAE,CAAC;IACzB,IAAI,kBAAkB,GAAG,EAAE,CAAC;IAC5B,IAAI,sBAAsB,GAAG,KAAK,CAAC;IAEnC,IAAI,mBAAmB,GAAG,EAAE,CAAC;IAC7B,IAAI,+BAA+B,GAAG,EAAE,CAAC;IACzC,IAAI,kBAAkB,GAAG,EAAE,CAAC;IAC5B,IAAI,cAAc,GAAG,EAAE,CAAC;IACxB,IAAI,iBAAiB,GAAG,EAAE,CAAC;IAC3B,IAAI,qBAAqB,GAAG,EAAE,CAAC;IAE/B,EAAE,CAAC,CAAC,gBAAgB,IAAI,IAAI,CAAC,CAAC,CAAC;QAC7B,oBAAoB,GAAG,2BAA2B,CAAC;QACnD,gCAAgC,GAAG,mDACzB,gBAAgB,CAAC,CAAC,CAAC,UAAK,gBAAgB,CAAC,CAAC,CAAC,OAAI,CAAC;QAC1D,mBAAmB,GAAG,mDAAmD,CAAC;QAC1E,eAAe;YACX,4DAA4D,CAAC;QACjE,kBAAkB,GAAG,oDAAoD,CAAC;QAC1E,sBAAsB,GAAG,aAAa,CAAC;IACzC,CAAC;IAED,EAAE,CAAC,CAAC,eAAe,IAAI,IAAI,CAAC,CAAC,CAAC;QAC5B,mBAAmB,GAAG,0BAA0B,CAAC;QACjD,+BAA+B,GAAG,kDACxB,eAAe,CAAC,CAAC,CAAC,UAAK,eAAe,CAAC,CAAC,CAAC,OAAI,CAAC;QACxD,kBAAkB,GAAG,iDAAiD,CAAC;QACvE,cAAc,GAAG,yDAAyD,CAAC;QAC3E,iBAAiB,GAAG,iDAAiD,CAAC;QACtE,qBAAqB,GAAG,oBAAoB,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,+HAKH,oBAAoB,cACpB,mBAAmB,yEAIQ,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,8CAC9B,cAAc,CAAC,CAAC,CAAC,UAAK,cAAc,CAAC,CAAC,CAAC,4DAEjE,kBAAkB,CAAC,CAAC,CAAC,UAAK,kBAAkB,CAAC,CAAC,CAAC,kBAEnD,gCAAgC,cAChC,+BAA+B,uFAGD,eAAe,uMAO3C,mBAAmB,gBACnB,kBAAkB,sJAIlB,eAAe,gBACf,cAAc,sLAKd,kBAAkB,gBAClB,iBAAiB,kFAGjB,qBAAqB,sFAEU,sBAAsB,qHAIvD,CAAC;AACP,CAAC;AAxFD,0DAwFC;AAED,4BACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,YAA8B,EAAE,IAAkB,EAClD,eAAiC,EAAE,QAAsB,EACzD,mBAAqC,EAAE,MAAyB,EAChE,iBAAwC,EAAE,KAAwB,EAClE,gBAAuC,EAAE,MAAoB,EAC7D,iBAAmC;IACrC,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IACvC,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IACrD,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;QACnB,KAAK,CAAC,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzD,SAAS,EAAE,CAAC;IACd,CAAC;IACD,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC;QAClB,KAAK,CAAC,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IACzD,CAAC;IACD,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAvBD,gDAuBC;;;;;ACnHD,iDAA6C;AAE7C,iCACI,SAAiB,EAAE,SAAiB,EAAE,EAAU;IAClD,MAAM,CAAC,uLAO4B,SAAS,iDACT,SAAS,oBACtC,EAAE,YACJ,CAAC;AACP,CAAC;AAbD,0DAaC;AAED,kBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,YAA8B,EAAE,CAAe,EAC/C,YAA8B,EAAE,MAAoB,EACpD,iBAAmC;IACrC,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAXD,4BAWC;AAED,gCACI,CAAe,EAAE,MAAwB,EAAE,CAAe,EAC1D,MAAwB,EAAE,oBAA4B;IACxD,IAAM,KAAK,GAAG,IAAI,4BAAY,EAAE,CAAC;IACjC,IAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAE1D,IAAM,QAAQ,GACV,KAAK,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,IAAM,QAAQ,GACV,KAAK,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpD,IAAM,WAAW,GACb,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAErE,IAAM,aAAa,GACf,KAAK,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/D,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE/D,QAAQ,CACJ,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EACjE,WAAW,CAAC,CAAC;IACjB,IAAM,MAAM,GAAG,KAAK,CAAC,yBAAyB,CAC1C,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAEnD,KAAK,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IACzC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAChB,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAhCD,wDAgCC;;;;;AC9DD,wCAA0C;AAG1C,iCACI,UAAoC,EAAE,UAAoC,EAC1E,cAAwC,EAAE,IAAY;IACxD,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACjE,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAEjE,IAAM,KAAK,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,IAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAE/B,MAAM,CAAC,2HAKyB,YAAY,CAAC,CAAC,CAAC,UAAK,YAAY,CAAC,CAAC,CAAC,4CACnC,YAAY,CAAC,CAAC,CAAC,YAAO,YAAY,CAAC,CAAC,CAAC,oPASnC,cAAc,CAAC,CAAC,CAAC,6CACpB,cAAc,CAAC,CAAC,CAAC,sDAItC,UAAU,WAAM,UAAU,CAAC,IAAI,CAAC,gGAEZ,UAAU,CAAC,CAAC,CAAC,yIAInC,UAAU,WAAM,UAAU,WAAM,UAAU,CAAC,IAAI,CAAC,gGAG1B,UAAU,CAAC,CAAC,CAAC,gLAMvC,CAAC;AACP,CAAC;AA7CD,0DA6CC;AAED,kBACI,KAAmB,EAAE,OAAqB,EAAE,EAAgB,EAC5D,EAAgB,EAAE,MAAoB,EAAE,aAA+B;IACzE,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACzC,KAAK,CAAC,qBAAqB,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACzC,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,4BAQC;;;;;AC1DD,wCAA0C;AAE1C,qCAAuC;AAGvC,2CACI,iBAA2C,EAAE,KAAa,EAC1D,WAAmB,EAAE,MAAc,EAAE,OAAe;IACtD,IAAM,uBAAuB,GACzB,QAAQ,CAAC,8CAA8C,EAAE,CAAC;IAC9D,IAAM,UAAU,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAExC,IAAM,WAAW,GAAG,SAAS,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;IAEvE,IAAM,MAAM,GAAG,SAAS,CAAC,oBAAoB,CACzC,iBAAiB,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5D,IAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAM,WAAW,GAAG,SAAS,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAE5D,IAAM,oBAAoB,GAAG,KAAK,GAAG,UAAU,CAAC;IAEhD,IAAM,QAAQ,GAAG,uFAIhB,CAAC;IAEF,MAAM,CAAC,QAAQ,GAAG,IAAI,GAAG,uBAAuB,GAAG,IAAI;SACnD,+EAE2B,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,4CAChC,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,+KAM/B,oBAAoB,0DACV,oBAAoB,oDACzB,UAAU,kDACb,UAAU,wPAMd,QAAQ,uDACX,MAAM,aAAQ,OAAO,qGAGhB,QAAQ,yDACX,MAAM,aAAQ,OAAO,qLAIR,UAAU,YAAO,WAAW,oiBAiBpE,CAAA,CAAC;AACP,CAAC;AArED,8EAqEC;AAED,8CACI,SAAmC,EAAE,KAAa,EAAE,cAAsB,EAC1E,UAAkB,EAAE,OAAe,EAAE,OAAgB;IACvD,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;IACzB,IAAA,oBAAK,EAAE,oBAAK,EAAE,8BAAe,CAAc;IAElD,IAAM,WAAW,GAAG,SAAS,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC/D,IAAM,WAAW,GACb,SAAS,CAAC,sBAAsB,CAAC,cAAc,EAAE,eAAe,EAAE,KAAK,CAAC,CAAC;IAE7E,IAAM,YAAY,GAAG,OAAO;QACxB,QAAQ,CAAC,mCAAmC,CAAC,cAAc,CAAC;QAC5D,EAAE,CAAC;IACP,IAAM,YAAY,GAAG,OAAO,GAAG,2BAA2B,GAAG,EAAE,CAAC;IAChE,IAAM,aAAa,GAAG,OAAO,GAAG,sCAAsC,GAAG,EAAE,CAAC;IAE5E,IAAM,QAAQ,GAAG,iGAIb,YAAY,WACb,CAAC;IAEJ,MAAM,CAAC,QAAQ,GAAG,IAAI,GAAG,YAAY,GAAG,IAAI;SACxC,+EAE2B,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,2CACjC,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,uMAO9B,cAAc,6CACjB,cAAc,2DAEF,GAAG,YAAO,GAAG,oSAOxB,KAAK,iEAEA,UAAU,6KAGjB,KAAK,2FAIZ,KAAK,uFAGM,KAAK,mEAEA,UAAU,6CACjB,KAAK,iGAIZ,KAAK,yDACG,KAAK,aAAQ,cAAc,+CAC3B,cAAc,wDAEX,eAAe,yDACpB,eAAe,ucAexC,aAAa,0DAEf,CAAA,CAAC;AACP,CAAC;AAtFD,oFAsFC;AAED,wCACI,UAAoC;IACtC,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC1D,IAAA,wBAAQ,EAAE,wBAAQ,EAAE,2BAAW,CAAe;IAErD,MAAM,CAAC,yIAKyB,YAAY,CAAC,CAAC,CAAC,UAAK,YAAY,CAAC,CAAC,CAAC,gOASnC,QAAQ,yFAGN,QAAQ,oHAEb,WAAW,gRAUpC,CAAC;AACP,CAAC;AAnCD,wEAmCC;AAED,iBACI,KAAmB,EAAE,OAAqB,EAAE,KAAmB,EAC/D,MAAoB,EAAE,gBAAkC;IAC1D,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,0BAQC;AAED,oBACI,KAAmB,EAAE,OAAqB,EAAE,IAAkB,EAC9D,KAAmB,EAAE,MAAoB,EACzC,gBAAkC;IACpC,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1C,KAAK,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAVD,gCAUC;AAED,uBACI,KAAmB,EAAE,OAAqB,EAAE,IAAkB,EAC9D,UAAwB,EAAE,SAA4B,EACtD,SAAuB,EAAE,gBAAkC;IAC7D,KAAK,CAAC,sBAAsB,CACxB,SAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1C,KAAK,CAAC,qBAAqB,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IACtD,EAAE,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC;QACtB,KAAK,CAAC,qBAAqB,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IACtD,CAAC;IACD,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAbD,sCAaC;;;;;AC5OD,wCAA0C;AAG1C;IACE,MAAM,CAAC,mJAKkB,CAAC;AAC5B,CAAC;AAPD,0EAOC;AAED;IACE,MAAM,CAAC,+bASH,CAAC;AACP,CAAC;AAXD,wGAWC;AAED,yCACI,SAAmC,EAAE,KAAa,EAAE,WAAmB,EACvE,MAAc,EAAE,GAAW,EAAE,OAAgB;IACxC,IAAA,oBAAK,EAAE,oBAAK,EAAE,yBAAU,CAAc;IAE7C,IAAM,WAAW,GAAG,SAAS,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC/D,IAAM,WAAW,GACb,SAAS,CAAC,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAErE,MAAM,CAAC,+EAEwB,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,2CACjC,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,uMAO9B,WAAW,6CACd,WAAW,oFAGC,MAAM,UAAK,MAAM,4BAC7C,GAAG,YAAO,GAAG,oSAOI,KAAK,4HAIH,KAAK,qGAGH,UAAU,yDACf,UAAU,iDACV,KAAK,GAAG,UAAU,mCAC5B,UAAU,oXAarB,OAAO,oHAIb,CAAC;AACP,CAAC;AA3DD,0EA2DC;AAED,6CAAoD,WAAmB;IAErE,MAAM,CAAC,qGAE6B,WAAW,mDACX,WAAW,2HAG3C,CAAC;AACP,CAAC;AATD,kFASC;AAED,iCACI,iBAA2C,EAAE,WAAmB,EAChE,SAAiB,EAAE,MAAc,EAAE,OAAe,EAClD,OAAgB;IAClB,IAAM,QAAQ,GACV,SAAS,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;IAEvD,IAAM,aAAa,GAAqB,SAAS,CAAC,sBAAsB,CACpE,iBAAiB,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;IAElD,IAAM,QAAQ,GAAG,+BAA+B,EAAE,CAAC;IACnD,IAAM,uBAAuB,GACzB,8CAA8C,EAAE,CAAC;IACrD,IAAM,QAAQ,GAAG,+BAA+B,CAC5C,iBAAiB,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACzE,IAAM,YAAY,GAAG,mCAAmC,CAAC,WAAW,CAAC,CAAC;IAEtE,MAAM,CAAC;QACL,QAAQ;QACR,uBAAuB;QACvB,YAAY;QACZ,QAAQ;KACT,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAvBD,0DAuBC;AAED,kBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,OAAqB,EAAE,MAAyB,EAAE,MAAoB,EACtE,iBAAmC;IACrC,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IACvC,KAAK,CAAC,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IACnD,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;QACnB,KAAK,CAAC,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;IACD,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAbD,4BAaC;;;;;ACrID,iCACI,iBAAmC,EAAE,gBAAkC,EACvE,cAAgC;IAClC,MAAM,CAAC,+KAOI,iBAAiB,CAAC,CAAC,CAAC,UAAK,iBAAiB,CAAC,CAAC,CAAC,sDAE7C,gBAAgB,CAAC,CAAC,CAAC,UAAK,gBAAgB,CAAC,CAAC,CAAC,oDAE3C,cAAc,CAAC,CAAC,CAAC,UAAK,cAAc,CAAC,CAAC,CAAC,2dAU9C,CAAC;AACP,CAAC;AAzBD,0DAyBC;AAED,cACI,KAAmB,EAAE,OAAqB,EAAE,MAAoB,EAChE,iBAAmC,EAAE,iBAAmC,EACxE,gBAAkC,EAAE,IAAkB,EACtD,eAAiC,EAAE,eAAiC,EACpE,cAAgC;IAClC,KAAK,CAAC,sBAAsB,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,KAAK,CAAC,0BAA0B,CAC5B,eAAe,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EACzD,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;IACvB,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IACjD,IAAM,gBAAgB,GAAG,KAAK,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACnE,KAAK,CAAC,EAAE,CAAC,SAAS,CACd,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,IAAM,cAAc,GAAG,KAAK,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IAC/D,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAlBD,oBAkBC;;;;;AC9CD,2CAA6C;AAE7C;IACE,MAAM,CAAC,2CAA2C,CAAC;AACrD,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,aAAa,EAAE,CAAC,CAAC;AAC9D,CAAC;AAFD,0DAEC;AAED,aACI,KAAmB,EAAE,UAAwB,EAAE,CAAe,EAC9D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACnE,CAAC;AAJD,kBAIC;AAED,2BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;AAC9E,CAAC;AAHD,8CAGC;;;;;ACpBD,yCAA2C;AAC3C,qCAAuC;AACvC,yCAA2C;AAI3C;IAaE,sBAAY,EAA0B;QALtC,kBAAa,GAAsB,IAAI,CAAC;QACxC,YAAO,GAAsB,IAAI,CAAC;QAC1B,aAAQ,GAAG,KAAK,CAAC;QACjB,sBAAiB,GAAG,KAAK,CAAC;QAGhC,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;YACf,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACf,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;QAC5C,CAAC;QAGD,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,qBAAqB;gBACtB,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,mBAAmB,CAAC,CAAC;QACnE,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,IAAI,CAAC,yBAAyB;gBAC1B,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,wBAAwB,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,oBAAoB;YACrB,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,oBAAoB,CACnC,CAAC;QAC9B,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3D,CAAC;IAEM,8BAAO,GAAd;QAAA,iBA0BC;QAzBC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,OAAO,CAAC,IAAI,CACR,+DAA+D;gBAC/D,6DAA6D;gBAC7D,8CAA8C,CAAC,CAAC;QACtD,CAAC;QACD,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,CAAC,CAAC;YAC/B,OAAO,CAAC,IAAI,CACR,gEAAgE;gBAChE,gEAAgE;gBAChE,8DAA8D;gBAC9D,YAAY,CAAC,CAAC;QACpB,CAAC;QACD,IAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACnB,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,MAAM,EAAE,EAAX,CAAW,CAAC,CAAC;QAC/C,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,EAAxC,CAAwC,CAAC,CAAC;QAC5E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,iBAAiB,CAAC,KAAI,CAAC,WAAW,CAAC,EAAtC,CAAsC,CAAC,CAAC;QAC1E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,EAApC,CAAoC,CAAC,CAAC;QACxE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,KAAI,CAAC,YAAY,CAAC,EAAlC,CAAkC,CAAC,CAAC;QACtE,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,oBAAoB,EAAE,IAAI,CAAC,EAA5C,CAA4C,CAAC,CAAC;QAC5D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,KAAI,CAAC,WAAW,CAAC,EAAjC,CAAiC,CAAC,CAAC;QACrE,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;IAEM,qDAA8B,GAArC,UAAsC,OAAgB;QACpD,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC;QACjC,UAAU,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAEM,0CAAmB,GAA1B,UAA2B,IAAY,EAAE,OAAe;QACtD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,CAAC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAEM,+CAAwB,GAA/B,UACI,OAAqB,EACrB,MAAqE;QACvE,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,UAAU,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;IAEM,gDAAyB,GAAhC,UAAiC,IAAY,EAAE,OAAe;QAE5D,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,CAAC,UAAU,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAEM,0CAAmB,GAA1B,UAA2B,OAAqB;QAAhD,iBAOC;QANC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC;YACnC,UAAU,CAAC,iCAAiC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACxE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;QACD,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,cAAM,OAAA,KAAI,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,EAA9B,CAA8B,CAAC,CAAC;IACzE,CAAC;IAEM,4CAAqB,GAA5B,UACI,OAAqB,EAAE,IAAY,EAAE,OAAe,EACpD,MAAoB;QACtB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAM,WAAW,GAAG,CAAC,CAAC;QACtB,MAAM,CAAC,UAAU,CAAC,qBAAqB,CACnC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC5D,CAAC;IAEM,kDAA2B,GAAlC,UACI,OAAqB,EAAE,IAAY,EAAE,OAAe,EACpD,MAAoB;QACtB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,CAAC,UAAU,CAAC,2BAA2B,CACzC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAEM,gDAAyB,GAAhC,UACI,OAAqB,EAAE,IAAY,EAAE,OAAe;QADxD,iBAMC;QAJC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAC5B,OAAO,EACP;YACI,OAAA,UAAU,CAAC,+BAA+B,CAAC,KAAI,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC;QAAlE,CAAkE,CAAC,CAAC;IAC9E,CAAC;IAEM,sDAA+B,GAAtC,UACI,OAAqB,EAAE,IAAY,EAAE,OAAe;QADxD,iBAMC;QAJC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAC5B,OAAO,EACP,cAAM,OAAA,UAAU,CAAC,qCAAqC,CAClD,KAAI,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,EADrB,CACqB,CAAC,CAAC;IACnC,CAAC;IAEM,oCAAa,GAApB,UAAqB,oBAA4B;QAC/C,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACnB,IAAM,cAAc,GAChB,UAAU,CAAC,oBAAoB,CAAC,EAAE,EAAE,oBAAoB,CAAC,CAAC;QAC9D,IAAM,YAAY,GAAgB,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;QACpE,IAAM,OAAO,GAAiB,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAC3D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,EAAtC,CAAsC,CAAC,CAAC;QAC1E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,EAAxC,CAAwC,CAAC,CAAC;QAC5E,UAAU,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACpC,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAC3B,UAAU,CAAC,eAAe,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC1C,CAAC;QACD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,EAAtC,CAAsC,CAAC,CAAC;QAC1E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,EAA7B,CAA6B,CAAC,CAAC;QACjE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC,EAAxC,CAAwC,CAAC,CAAC;QAC5E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,cAAc,CAAC,EAA/B,CAA+B,CAAC,CAAC;QACnE,MAAM,CAAC,OAAO,CAAC;IACjB,CAAC;IAEM,oCAAa,GAApB,UAAqB,OAAqB;QAA1C,iBAQC;QAPC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,EAAE,CAAC,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACpB,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,cAAM,OAAA,KAAI,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,EAA9B,CAA8B,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IAEM,iCAAU,GAAjB,UAAkB,OAA0B;QAA5C,iBAOC;QANC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;YACrD,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,CAAC;QACD,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,cAAM,OAAA,KAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAA3B,CAA2B,CAAC,CAAC;IACtE,CAAC;IAEM,yCAAkB,GAAzB,UAA0B,WAAmB;QAC3C,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,MAAM,CAAC,UAAU,CAAC,gCAAgC,CAC9C,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,OAAQ,EAAE,WAAW,CAAC,CAAC;IAC3C,CAAC;IAEM,4CAAqB,GAA5B,UACI,kBAAgC,EAAE,WAAmB,EACrD,WAAmB;QACrB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,UAAU,CAAC,kCAAkC,CACzC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,OAAQ,EAAE,kBAAkB,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;IAC5E,CAAC;IAEM,6CAAsB,GAA7B,UACI,mBAAiC,EAAE,IAAY,EAAE,OAAe;QAClE,IAAI,CAAC,4BAA4B,CAAC,mBAAmB,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACxE,CAAC;IAEM,mDAA4B,GAAnC,UACI,yBAAuC,EAAE,IAAY,EAAE,OAAe;QACxE,IAAI,CAAC,eAAe,EAAE,CAAC;QACjB,IAAA,mEAC4D,EAD3D,aAAK,EAAE,cAAM,CAC+C;QACnE,IAAI,CAAC,4BAA4B,CAAC,yBAAyB,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC9E,CAAC;IAEM,iDAA0B,GAAjC,UACI,QAAgB,EAAE,OAAe,EAAE,WAAmB,EACtD,UAAkB;QACpB,IAAI,CAAC,gCAAgC,CACjC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAEM,uDAAgC,GAAvC,UACI,QAAgB,EAAE,OAAe,EAAE,WAAmB,EACtD,UAAkB;QACpB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IAEM,oCAAa,GAApB;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,CAAC;QACD,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1C,CAAC;IAEM,qCAAc,GAArB;QACE,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACnB,UAAU,CAAC,iCAAiC,CACxC,EAAE,EAAE,IAAI,CAAC,OAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1C,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAC3B,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;QACD,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC,EAAtD,CAAsD,CAAC,CAAC;IACxE,CAAC;IAEM,qDAA8B,GAArC;QAAA,iBAGC;QAFC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,cAAM,OAAA,KAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAhB,CAAgB,CAAC,CAAC;IAC3D,CAAC;IAEO,2CAAoB,GAA5B,UACI,OAAqB,EACrB,iBAAqC;QACvC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,UAAU,CAAC,6BAA6B,CACpC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QACxC,IAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACnC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,CAAC,CAAC;YAC/B,UAAU,CAAC,6BAA6B,CACpC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACnD,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBAC3B,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,UAAU,CAAC,iCAAiC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1E,CAAC;QACD,MAAM,CAAC,MAAM,CAAC;IAChB,CAAC;IAEO,mDAA4B,GAApC,UACI,8BAA4C,EAAE,KAAa,EAC3D,MAAc;QAChB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACnB,UAAU,CAAC,6BAA6B,CACpC,EAAE,EAAE,8BAA8B,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1D,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAC3B,UAAU,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,aAAa,GAAG,8BAA8B,CAAC;QACpD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAhC,CAAgC,CAAC,CAAC;QACpE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAA/B,CAA+B,CAAC,CAAC;IACrE,CAAC;IAEO,uDAAgC,GAAxC,UACI,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc;QADvD,iBAKC;QAHC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,UAAU,CAAC,YAAY,CACnB,IAAI,CAAC,EAAE,EAAE,cAAM,OAAA,KAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAApC,CAAoC,CAAC,CAAC;IAC3D,CAAC;IAEO,sCAAe,GAAvB;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAEO,uCAAgB,GAAxB;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IACH,mBAAC;AAAD,CAhSA,AAgSC,IAAA;AAhSY,oCAAY;;;;;ACNzB,qCAAuC;AACvC,yCAA2C;AAE3C;IACE,MAAM,CAAC;QACL,KAAK,EAAE,KAAK;QACZ,SAAS,EAAE,KAAK;QAChB,kBAAkB,EAAE,KAAK;QACzB,qBAAqB,EAAE,KAAK;QAC5B,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,4BAA4B,EAAE,IAAI;KACnC,CAAC;AACJ,CAAC;AAVD,8DAUC;AAED,4BAAmC,MAA0B;IAC3D,IAAM,UAAU,GAAG,yBAAyB,EAAE,CAAC;IAC/C,IAAI,EAAyB,CAAC;IAC9B,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC;QACnB,EAAE,GAAG,UAAU,CAAC,qCAAqC,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC5E,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,EAAE,GAAG,UAAU,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;IAC1D,CAAC;IACD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,EAAzB,CAAyB,CAAC,CAAC;IAC7D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,EAA3B,CAA2B,CAAC,CAAC;IAC/D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,EAApB,CAAoB,CAAC,CAAC;IACxD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,EAArB,CAAqB,CAAC,CAAC;IACzD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,mBAAmB,CAAC,EAAlC,CAAkC,CAAC,CAAC;IACtE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,eAAe,CAAC,EAA9B,CAA8B,CAAC,CAAC;IAClE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,EAA1B,CAA0B,CAAC,CAAC;IAC9D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,EAAvB,CAAuB,CAAC,CAAC;IAC3D,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,EAApB,CAAoB,CAAC,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC;AACZ,CAAC;AAlBD,gDAkBC;AAED,4BAAmC,EAAyB;IAC1D,IAAM,kBAAkB,GAAG,kNASvB,CAAC;IACL,MAAM,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC;AAC/D,CAAC;AAZD,gDAYC;AAED,4BAAmC,EAAyB;IAE1D,IAAM,WAAW,GAAG,IAAI,YAAY,CAChC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACtE,MAAM,CAAC,UAAU,CAAC,wBAAwB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;AAC9D,CAAC;AALD,gDAKC;AAED,2BAAkC,EAAyB;IAEzD,IAAM,qBAAqB,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClE,MAAM,CAAC,UAAU,CAAC,uBAAuB,CAAC,EAAE,EAAE,qBAAqB,CAAC,CAAC;AACvE,CAAC;AAJD,8CAIC;AAED,kCACI,EAAyB,EAAE,WAAmB;IAChD,EAAE,CAAC,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QACjC,EAAE,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC;YAEtB,MAAM,CAAE,EAAU,CAAC,OAAO,CAAC;QAC7B,CAAC;QAED,MAAM,CAAE,EAAU,CAAC,IAAI,CAAC;IAC1B,CAAC;IACD,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC;AACjB,CAAC;AAED,0BACI,EAAyB,EAAE,WAAmB;IAChD,EAAE,CAAC,CAAC,UAAU,CAAC,eAAe,EAAE,IAAI,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC;QAEtD,MAAM,CAAE,EAAU,CAAC,GAAG,CAAC;IACzB,CAAC;IACD,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC;AACjB,CAAC;AAED,mCACI,EAAyB,EAAE,KAAa,EAAE,MAAc,EACxD,WAAmB;IACrB,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,IAAM,OAAO,GAAG,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IAE7C,IAAM,KAAK,GAAG,EAAE,CAAC,UAAU,CAAC;IAC5B,IAAM,cAAc,GAAG,wBAAwB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACjE,IAAM,MAAM,GAAG,gBAAgB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACjD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,EAA9B,CAA8B,CAAC,CAAC;IAClE,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC,aAAa,CAAC,EAA5D,CAA4D,CAAC,CAAC;IAC5E,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC,aAAa,CAAC,EAA5D,CAA4D,CAAC,CAAC;IAC5E,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC,OAAO,CAAC,EAA1D,CAA0D,CAAC,CAAC;IAC1E,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC,OAAO,CAAC,EAA1D,CAA0D,CAAC,CAAC;IAC1E,UAAU,CAAC,YAAY,CACnB,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,UAAU,CACf,KAAK,EAAE,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EADjE,CACiE,CAAC,CAAC;IAC7E,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAnC,CAAmC,CAAC,CAAC;IACvE,MAAM,CAAC,OAAO,CAAC;AACjB,CAAC;AAED,6BACI,EAAyB,EAAE,IAAY,EAAE,OAAe;IACpD,IAAA,qEAC8D,EAD7D,aAAK,EAAE,cAAM,CACiD;IACrE,IAAM,WAAW,GAAG,CAAC,CAAC;IACtB,MAAM,CAAC,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;AACnE,CAAC;AAND,kDAMC;AAED,kCACI,EAAyB,EAAE,IAAY,EAAE,OAAe;IACpD,IAAA,kEAC2D,EAD1D,aAAK,EAAE,cAAM,CAC8C;IAClE,IAAM,WAAW,GAAG,CAAC,CAAC;IACtB,MAAM,CAAC,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;AACnE,CAAC;AAND,4DAMC;AAED,mCACI,EAAyB,EAAE,IAAY,EAAE,OAAe;IACpD,IAAA,mEAC4D,EAD3D,aAAK,EAAE,cAAM,CAC+C;IACnE,IAAM,WAAW,GAAG,CAAC,CAAC;IACtB,MAAM,CAAC,yBAAyB,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;AACnE,CAAC;AAND,8DAMC;AAED,2CACI,EAAyB,EAAE,OAAqB,EAChD,YAAyB;IAC3B,IAAM,SAAS,GAAG,CAAC,CAAC;IACpB,IAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,IAAM,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,EAA5C,CAA4C,CAAC,CAAC;IAC5D,UAAU,CAAC,kCAAkC,CACzC,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IACrE,IAAI,CAAC;QACH,UAAU,CAAC,kCAAkC,CACzC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC5D,CAAC;IAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAIX,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,8BAA8B,CAAC,CAAC,CAAC,CAAC;YACtD,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;AACH,CAAC;AArBD,8EAqBC;AAED,kCACI,EAAyB,EAAE,OAAqB,EAChD,MAAqE;IACvE,IAAM,WAAW,GAAG,CAAC,CAAC;IACtB,IAAM,cAAc,GAAG,wBAAwB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACjE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAtC,CAAsC,CAAC,CAAC;IAC1E,UAAU,CAAC,YAAY,CACnB,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,UAAU,CACf,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAD1D,CAC0D,CAAC,CAAC;IACtE,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAnC,CAAmC,CAAC,CAAC;AACzE,CAAC;AAXD,4DAWC;AAED,6BACI,EAAyB,EAAE,OAAqB,EAAE,KAAa,EAC/D,MAAc,EAAE,IAAkB,EAAE,WAAmB;IACzD,IAAM,aAAa,GAAG,gBAAgB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IAExD,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAtC,CAAsC,CAAC,CAAC;IAC1E,UAAU,CAAC,YAAY,CACnB,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,aAAa,CAClB,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC,KAAK,EAC9D,IAAI,CAAC,EAFH,CAEG,CAAC,CAAC;IACf,UAAU,CAAC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAnC,CAAmC,CAAC,CAAC;AACzE,CAAC;AAED,+BACI,EAAyB,EAAE,OAAqB,EAAE,IAAY,EAC9D,OAAe,EAAE,MAAoB,EAAE,WAAmB;IACtD,IAAA,qEAC8D,EAD7D,SAAC,EAAE,SAAC,CAC0D;IAErE,IAAM,kBAAkB,GACpB,WAAW,KAAK,CAAC,GAAG,UAAU,CAAC,qBAAqB,EAAE,GAAG,WAAW,CAAC;IACzE,IAAM,aAAa,GACf,IAAI,YAAY,CAAC,QAAQ,CAAC,kCAAkC,CACxD,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAC5C,QAAQ,CAAC,2BAA2B,CAChC,MAAM,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;IAE/C,mBAAmB,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC;AACrE,CAAC;AAfD,sDAeC;AAED,qCACI,EAAyB,EAAE,OAAqB,EAAE,IAAY,EAC9D,OAAe,EAAE,MAAoB;IACjC,IAAA,mEAAuE,EAAtE,SAAC,EAAE,SAAC,CAAmE;IAC9E,IAAM,UAAU,GAAG,IAAI,YAAY,CAC/B,QAAQ,CAAC,qCAAqC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,wBAAwB,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IACrE,IAAM,WAAW,GAAG,CAAC,CAAC;IACtB,mBAAmB,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;AAClE,CAAC;AATD,kEASC;AAED,yCACI,EAAyB,EAAE,IAAY,EAAE,OAAe;IACpD,IAAA,qEAC8D,EAD7D,SAAC,EAAE,SAAC,CAC0D;IAErE,IAAM,kBAAkB,GAAG,CAAC,CAAC;IAC7B,IAAM,aAAa,GACf,IAAI,YAAY,CAAC,QAAQ,CAAC,kCAAkC,CACxD,IAAI,GAAG,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAC7C,IAAM,aAAa,GAAG,gBAAgB,CAAC,EAAE,EAAE,kBAAkB,CAAC,CAAC;IAE/D,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,EAA3D,CAA2D,CAAC,CAAC;IAE3E,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;IAChD,QAAQ,CAAC,6BAA6B,CAClC,aAAa,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC/C,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAlBD,0EAkBC;AAED,+CACI,EAAyB,EAAE,IAAY,EAAE,OAAe;IACpD,IAAA,mEAAuE,EAAtE,SAAC,EAAE,SAAC,CAAmE;IAC9E,IAAM,UAAU,GAAG,IAAI,YAAY,CAC/B,QAAQ,CAAC,qCAAqC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACnE,UAAU,CAAC,YAAY,CACnB,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,EAAxD,CAAwD,CAAC,CAAC;IACxE,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;IAChD,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAChF,CAAC;AATD,sFASC;;;;;ACjPD,2CAA6C;AAE7C;IACE,MAAM,CAAC,2CAA2C,CAAC;AACrD,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,aAAa,EAAE,CAAC,CAAC;AAC9D,CAAC;AAFD,0DAEC;AAED,aACI,KAAmB,EAAE,UAAwB,EAAE,CAAe,EAC9D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACnE,CAAC;AAJD,kBAIC;AAED,2BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;AAC9E,CAAC;AAHD,8CAGC;;;;;ACpBD,iDAA6C;AAE7C,iCAAwC,IAAY,EAAE,OAAe;IACnE,MAAM,CAAC,8HAKsB,OAAO,YAAO,IAAI,yvBAuB3C,CAAC;AACP,CAAC;AA9BD,0DA8BC;AAED,mBACI,KAAmB,EAAE,gBAA8B,EAAE,CAAe,EACpE,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACnC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAPD,8BAOC;AAED,iCACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,IAAM,KAAK,GAAG,IAAI,4BAAY,EAAE,CAAC;IACjC,IAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,uBAAuB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5E,IAAM,QAAQ,GAAG,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1D,IAAM,aAAa,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACxD,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;IAClE,IAAM,MAAM,GAAG,KAAK,CAAC,yBAAyB,CAAC,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IACzC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAChB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AACnB,CAAC;AAdD,0DAcC;;;;;ACzDD,wCAA0C;AAG1C,0CACI,UAAoC,EAAE,KAAa,EAAE,UAAkB,EACvE,OAAe;IACjB,IAAM,cAAc,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IACrC,IAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC;IACzB,IAAA,sBAAM,EAAE,sBAAM,EAAE,qBAAK,CAAe;IAE3C,IAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAEjE,MAAM,CAAC,wKAMyB,YAAY,CAAC,CAAC,CAAC,UAAK,YAAY,CAAC,CAAC,CAAC,+MAO/B,cAAc,6CACnB,cAAc,8DAEC,GAAG,YAAO,GAAG,2SAO3B,KAAK,mEAEE,UAAU,gLAGjB,MAAM,sIAMJ,KAAK,qEAEE,UAAU,+CACjB,MAAM,wGAIT,KAAK,qQAQtB,KAAK,GAAG,KAAK,GAAG,CAAC,uLAII,KAAK,qMAOpC,CAAC;AACP,CAAC;AAtED,4EAsEC;AAED,yBACI,KAAmB,EAAE,OAAqB,EAAE,KAAmB,EAC/D,eAA6B,EAAE,SAAuB,EACtD,gBAAkC;IACpC,KAAK,CAAC,sBAAsB,CACxB,SAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,KAAK,CAAC,qBAAqB,CAAC,eAAe,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1D,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAVD,0CAUC;;;;;ACpFD,qCAAuC;AAEvC,iDACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW;IACb,MAAM,CAAC,oCAAoC,CACvC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AALD,0FAKC;AAED,wCACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW;IACb,MAAM,CAAC,oCAAoC,CACvC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAC5C,CAAC;AALD,wEAKC;AAED,8CACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW,EAAE,mBAA4B;IAC3C,MAAM,CAAC,QAAQ,CAAC,iCAAiC,CAC7C,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC;AACjE,CAAC;AAED,uBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,MAAoB,EAAE,iBAAmC;IAC3D,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC;AACpE,CAAC;AAJD,sCAIC;;;;;AC3BD,qCAAuC;AAEvC,wCACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW;IACb,MAAM,CAAC,QAAQ,CAAC,iCAAiC,CAC7C,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACnD,CAAC;AALD,wEAKC;AAED,iBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,MAAoB,EAAE,iBAAmC;IAC3D,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC;AACpE,CAAC;AAJD,0BAIC;;;;;ACbD,2CAAgD;AAEhD,iCACI,IAAY,EAAE,OAAe,EAAE,MAAc;IAC/C,MAAM,CAAC,qIAKsB,OAAO,YAAO,IAAI,6DAG3C,+BAAkB,ydAaJ,MAAM,+FAIpB,CAAC;AACP,CAAC;AAED,oCACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC;AAHD,gEAGC;AAED,oCACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC;AAHD,gEAGC;AAED,gBACI,KAAmB,EAAE,aAA2B,EAAE,CAAe,EACjE,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAChC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAPD,wBAOC;;;;;AClDD,gCAA0C;AAI1C,mDAAqD;AAErD,2BACI,CAAU,EAAE,CAAU,EAAE,GAAY,EAAE,YAA+B,EACrE,YAA+B;IACjC,IAAM,SAAS,GACX,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,IAAM,QAAQ,GACV,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,SAAS,CAAC;IACzE,IAAM,QAAQ,GACV,CAAC,YAAY,KAAK,wBAAiB,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,SAAS,CAAC;IAEzE,IAAM,MAAM,GAAG,CAAC,EAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC,CAAC;IAC1E,IAAM,QAAQ,GAAG,mCACW,SAAS,8KAKR,QAAQ,yCACR,QAAQ,iMAUpC,CAAC;IACF,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC;AA9BD,8CA8BC;AAED,wBACI,KAAmB,EAAE,eAA6B,EAAE,CAAe,EACnE,CAAe,EAAE,MAAoB,EAAE,WAA6B;IACtE,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACrE,KAAK,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;IAClC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,wCAQC;;;;;AC7CD,2CAA6C;AAE7C;IACE,MAAM,CAAC,uCAAuC,CAAC;AACjD,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,aAAa,EAAE,CAAC,CAAC;AAC9D,CAAC;AAFD,0DAEC;AAED,aACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAAE,IAAY,EACzE,OAAe,EAAE,MAAoB;IACvC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAChE,CAAC;AAJD,kBAIC;AAED,2BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;AAC9E,CAAC;AAHD,8CAGC;;;;;ACpBD,wCAA0C;AAE1C,2CAAgD;AAEhD,2CACI,SAAmC,EAAE,KAAa,EAAE,MAAc,EAClE,GAAW,EAAE,QAA2B,EAAE,gBAAyB;IACrE,EAAE,CAAC,CAAC,QAAQ,KAAK,KAAK,IAAI,gBAAgB,CAAC,CAAC,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,IAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAE3B,IAAM,WAAW,GAAG,SAAS,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAE/D,IAAI,WAAW,GAAG,aAAa,CAAC;IAChC,EAAE,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC;QACrB,WAAW,GAAG,gBAAgB,CAAC;IACjC,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC;QAC9B,WAAW,GAAG,UAAU,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,mKAMwB,WAAW,CAAC,CAAC,CAAC,UAAK,WAAW,CAAC,CAAC,CAAC,kBAE5D,+BAAkB,qMAOY,KAAK,4CACT,KAAK,2DAEQ,MAAM,UAAK,MAAM,4BAC7C,GAAG,YAAO,GAAG,kVAWI,KAAK,4HAIH,KAAK,4FAEV,KAAK,ilBAkBpB,QAAQ,KAAK,KAAK,8CACA,KAAK,GAAG,KAAK,iRAMvB,QAAQ,KAAK,KAAK,GAAG,IAAI,GAAG,IAAI,8HAGpC,gBAAgB,mDACI,KAAK,6GAMjB,WAAW,uBACjC,CAAC;AACP,CAAC;AA3FD,8EA2FC;AAED,oBACI,KAAmB,EAAE,OAAqB,EAAE,CAAe,EAC3D,MAAoB,EAAE,iBAAmC;IAC3D,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;IACvC,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,gCAQC;;;;;ACzGD,iDAA6C;AAE7C,iCAAwC,IAAY,EAAE,OAAe;IACnE,MAAM,CAAC,8HAKsB,OAAO,YAAO,IAAI,iXAY3C,CAAC;AACP,CAAC;AAnBD,0DAmBC;AAED,mBACI,KAAmB,EAAE,gBAA8B,EAAE,CAAe,EACpE,QAAgB,EAAE,QAAgB,EAAE,MAAoB;IAC1D,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACnC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAPD,8BAOC;AAED,iCACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,IAAM,KAAK,GAAG,IAAI,4BAAY,EAAE,CAAC;IACjC,IAAM,OAAO,GACT,KAAK,CAAC,aAAa,CAAC,uBAAuB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAChE,IAAM,QAAQ,GAAiB,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACxE,IAAM,aAAa,GAAiB,KAAK,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACxD,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;IAClE,IAAM,MAAM,GAAG,KAAK,CAAC,yBAAyB,CAAC,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvE,KAAK,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IACzC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAChB,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAfD,0DAeC;;;;;AC9CD,2CAA6C;AAE7C;IACE,MAAM,CAAC,kGAGN,CAAC;AACJ,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,cAAc,EAAE,CAAC,CAAC;AAC/D,CAAC;AAFD,0DAEC;AAED,cACI,KAAmB,EAAE,WAAyB,EAAE,CAAe,EAC/D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACpE,CAAC;AAJD,oBAIC;AAED,4BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;AAC/E,CAAC;AAHD,gDAGC;;;;;ACrBD,yCAA2C;AAE3C,4BACI,KAAmB,EAAE,gBAAwB;IAC/C,IAAM,oBAAoB,GAAG,mIAKM,gBAAgB,4eAgB/C,CAAC;IAEL,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;AACnD,CAAC;AA1BD,gDA0BC;AAED,wBACI,KAAmB,EAAE,YAA0B,EAAE,SAAuB;IAC1E,UAAU,CAAC,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC7C,mBAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;AACtD,CAAC;AAJD,wCAIC;AAED,6BACI,KAAmB,EAAE,YAA0B,EAAE,SAAuB;IAC1E,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC/B,KAAK,CAAC,qBAAqB,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;IACpD,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AALD,kDAKC;;;;;AC3CD,iCAAmC;AAGnC;IACE,MAAM,CAAC,0tBAoBH,CAAC;AACP,CAAC;AAtBD,0DAsBC;AAED,iBACI,KAAmB,EAAE,cAA4B,EAAE,CAAe,EAClE,QAAgB,EAAE,QAAgB,EAAE,MAAoB,EACxD,aAAqB,EAAE,aAAqB;IAC9C,IAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtC,IAAM,UAAU,GAAG,aAAa,GAAG,aAAa,CAAC;IACjD,IAAI,CAAC,MAAM,CACP,SAAS,KAAK,UAAU,EACxB,qBAAmB,SAAS,2BAAsB,UAAU,OAAI;QAC5D,YAAY,CAAC,CAAC;IAEtB,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,aAAa,CAAC,CAAC;IACnE,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACjC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAE7C,IAAM,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAClE,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAE3D,IAAM,mBAAmB,GAAG,KAAK,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IACpE,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,mBAAmB,EAAE,aAAa,EAAE,aAAa,CAAC,CAAC;IAEtE,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAtBD,0BAsBC;;;;;ACjDD,wCAA0C;AAK1C,iCACI,aAAuC,EACvC,sBAAwC,EAAE,YAAqB;IACjE,IAAM,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IAE/B,IAAM,eAAe,GAAG,SAAS,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;IAEvE,IAAM,sBAAsB,GAAG,YAAY;QACvC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;QACnD,aAAa,CAAC;IAElB,IAAM,uBAAuB,GAAG,YAAY;QACxC,CAAC,sBAAsB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;QACrE,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAElE,MAAM,CAAC,6KAM4B,aAAa,CAAC,CAAC,CAAC,UAAK,aAAa,CAAC,CAAC,CAAC,4DAEhE,eAAe,CAAC,CAAC,CAAC,UAAK,eAAe,CAAC,CAAC,CAAC,8EAGzC,sBAAsB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,mBACtD,sBAAsB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,kGAGlC,KAAK,qQAQM,KAAK,uDACd,KAAK,s5BAqB/B,CAAC;AACP,CAAC;AA7DD,0DA6DC;AAED,wBACI,KAAmB,EAAE,qBAAmC,EAAE,CAAe,EACzE,MAAoB,EAAE,iBAAmC;IAC3D,KAAK,CAAC,sBAAsB,CACxB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;IACxC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AARD,wCAQC;;;;;AC5ED,iCAAmC;AAOnC,uBAA8B,MAAiB,EAAE,MAAe;IAC9D,IAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,KAAK,GAAG,GAAG,GAAG,CAAC,CAAC,iBAAiB,EAAE,EAArC,CAAqC,CAAC,CAAC;IACnE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,GAAG,GAAG,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;AAC/E,CAAC;AAHD,sCAGC;AAED,oBACI,MAAe,EAAE,MAAe,EAAE,QAAgB;IACpD,IAAM,kBAAkB,GACpB,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,uBAAqB,CAAC,CAAC,IAAI,MAAG,EAA9B,CAA8B,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/D,IAAM,oBAAoB,GACtB,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,uBAAuB,CAAC,CAAC,CAAC,EAA1B,CAA0B,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,IAAM,WAAW,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;IAC/C,IAAM,qBAAqB,GACvB,wBAAwB,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACxD,IAAM,MAAM,GAAG;QACb,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,oBAAoB;QAC1E,qBAAqB,EAAE,QAAQ;KAChC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACb,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAdD,gCAcC;AAED,iCAAiC,KAAY;IAC3C,IAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC;IACxB,IAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IACxB,IAAM,QAAQ,GAAG,GAAG,CAAC,iBAAiB,CAAC,KAAyB,CAAC,CAAC;IAClE,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QACrB,KAAK,CAAC;YACJ,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,KAAyB,EAAE,QAAQ,CAAC,CAAC;QACvE;YACE,MAAM,IAAI,KAAK,CAAI,GAAG,CAAC,IAAI,2CAAwC,CAAC,CAAC;IACzE,CAAC;AACH,CAAC;AAED,kCACI,QAAkB,EAAE,WAA6B;IACnD,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC;YACJ,MAAM,CAAC,iBAAiB,CAAC,QAA4B,EAAE,WAAW,CAAC,CAAC;QACtE;YACE,MAAM,IAAI,KAAK,CACR,QAAQ,CAAC,MAAM,4CAAyC,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAED,IAAM,aAAa,GAAG,6KAQrB,CAAC;AAEF,IAAM,iBAAiB,GAAG,4WASzB,CAAC;AAEF,2BACI,KAAuB,EAAE,QAA0B;IACrD,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,yFAIN,CAAC;IACJ,CAAC;IACD,MAAM,CAAC,2HAGgC,QAAQ,CAAC,CAAC,CAAC,kDACpB,KAAK,CAAC,CAAC,CAAC,yCACX,KAAK,CAAC,CAAC,CAAC,8CAGlC,CAAC;AACJ,CAAC;AAED,sBACI,OAAe,EAAE,KAAuB,EAAE,QAA0B;IACtE,IAAM,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5E,IAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,IAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,mBACG,QAAQ,qFAC+B,EAAE,YAAO,EAAE,uCACrC,OAAO,4BAE7B,CAAC;IACJ,CAAC;IACD,MAAM,CAAC,iBACG,QAAQ,wDACI,OAAO,UAAK,EAAE,YAAO,EAAE,YAAO,KAAK,CAAC,CAAC,CAAC,8BAE3D,CAAC;AACJ,CAAC;;;;;AC7GD,2CAA6C;AAE7C;IACE,MAAM,CAAC,gEAAgE,CAAC;AAC1E,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,iBAAiB,EAAE,CAAC,CAAC;AAClE,CAAC;AAFD,wEAEC;AAED,iBACI,KAAmB,EAAE,cAA4B,EAAE,CAAe,EAClE,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACvE,CAAC;AAJD,0BAIC;AAED,+BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CACpC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAC7C,CAAC;AAJD,sDAIC;;;;;ACpBD,2CAA6C;AAE7C;IACE,MAAM,CAAC,mHAGN,CAAC;AACJ,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,cAAc,EAAE,CAAC,CAAC;AAC/D,CAAC;AAFD,0DAEC;AAED,cACI,KAAmB,EAAE,WAAyB,EAAE,CAAe,EAC/D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACpE,CAAC;AAJD,oBAIC;AAED,4BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;AAC/E,CAAC;AAHD,gDAGC;;;;;ACvBD,kDACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACzB,CAAC;AAHD,4FAGC;AAED,4CACI,UAAkB,EAAE,kBAA0B;IAChD,MAAM,CAAC,UAAU,GAAG,kBAAkB,CAAC;AACzC,CAAC;AAHD,gFAGC;AAED,+CACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,CAAC,OAAO,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;AAC7B,CAAC;AAHD,sFAGC;AAED,4CACI,YAAoB,EAAE,kBAA0B;IAClD,EAAE,CAAC,CAAC,YAAY,GAAG,kBAAkB,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5C,MAAM,IAAI,KAAK,CACX,gBAAgB,GAAG,YAAY,GAAG,0BAA0B;YAC5D,kBAAkB,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,CAAC,YAAY,GAAG,kBAAkB,CAAC;AAC3C,CAAC;AARD,gFAQC;AAED,qCACI,MAAoB,EAAE,aAA2B,EACjD,kBAA0B;IAC5B,IAAM,YAAY,GACd,kCAAkC,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC1E,EAAE,CAAC,CAAC,aAAa,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC;QACxC,MAAM,IAAI,KAAK,CACX,wBAAwB,GAAG,aAAa,CAAC,MAAM;YAC/C,eAAe,GAAG,YAAY,CAAC,CAAC;IACtC,CAAC;IACD,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC;QAC7C,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QACjC,GAAG,IAAI,kBAAkB,CAAC;IAC5B,CAAC;AACH,CAAC;AAfD,kEAeC;AAED,uCACI,aAA2B,EAAE,MAAoB,EACjD,kBAA0B;IAC5B,IAAM,YAAY,GAAG,kCAAkC,CACnD,aAAa,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC9C,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC;QACjC,MAAM,IAAI,KAAK,CACX,iBAAiB,GAAG,MAAM,CAAC,MAAM,GAAG,eAAe,GAAG,YAAY,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,GAAG,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,aAAa,CAAC,MAAM,EAAE,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACxE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;AACH,CAAC;AAbD,sEAaC;AAED,gDACI,IAAY,EAAE,OAAe;IAC/B,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;AACvD,CAAC;AAHD,wFAGC;AAED,+CACI,IAAY,EAAE,OAAe;IACzB,IAAA,0DAA8D,EAA7D,SAAC,EAAE,SAAC,CAA0D;IACrE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACnB,CAAC;AAJD,sFAIC;AAED,kCACI,MAAoB,EAAE,IAAY,EAAE,OAAe,EACnD,UAAwB;IAC1B,IAAM,YAAY,GAAG,qCAAqC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1E,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC;QACrC,MAAM,IAAI,KAAK,CACX,qBAAqB,GAAG,UAAU,CAAC,MAAM;YACzC,eAAe,GAAG,YAAY,CAAC,CAAC;IACtC,CAAC;IAeK,IAAA,0DACmD,EADlD,oBAAY,EAAE,qBAAa,CACwB;IAC1D,IAAM,QAAQ,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACrC,IAAM,SAAS,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACnC,IAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IAClD,IAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAGhD,CAAC;QACC,IAAM,SAAS,GAAG,CAAC,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACrC,IAAM,MAAM,GAAG,OAAO,CAAC;QACvB,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC3D,IAAM,YAAY,GAAG,CAAC,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;YAC5C,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;gBAC1D,IAAM,YAAY,GAAG,MAAM,GAAG,CAAC,CAAC;gBAChC,IAAM,GAAG,GAAG,YAAY,GAAG,YAAY,CAAC;gBACxC,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC9B,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;gBACtC,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC;gBAC3C,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;gBAC/C,GAAG,IAAI,CAAC,CAAC;YACX,CAAC;YACD,GAAG,IAAI,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;QACb,IAAI,GAAG,GAAG,OAAO,GAAG,CAAC,CAAC;QACtB,IAAI,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACjC,IAAM,SAAS,GAAG,CAAC,GAAG,OAAO,CAAC;QAC9B,IAAM,SAAS,GAAG,YAAY,GAAG,CAAC,CAAC;QACnC,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC3D,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC9B,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC,CAAC;YAC5C,GAAG,IAAI,SAAS,CAAC;YACjB,GAAG,IAAI,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC;QAC/B,IAAI,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,YAAY,GAAG,CAAC,CAAC;QACjD,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC1D,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;YAClC,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;YAClC,GAAG,IAAI,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC;QAC1B,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,CAAC,UAAU,CAAC;AACpB,CAAC;AAjFD,4DAiFC;AAED,oCACI,UAAwB,EAAE,IAAY,EAAE,OAAe,EACvD,MAAoB;IACtB,IAAM,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC;IACpC,EAAE,CAAC,CAAC,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACjC,MAAM,IAAI,KAAK,CACX,iBAAiB,GAAG,MAAM,CAAC,MAAM,GAAG,eAAe,GAAG,YAAY,CAAC,CAAC;IAC1E,CAAC;IACD,IAAM,QAAQ,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACrC,IAAM,SAAS,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACnC,IAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IAClD,IAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAC1C,IAAA,0DACmD,EADlD,oBAAY,EAAE,qBAAa,CACwB;IAG1D,CAAC;QACC,IAAM,SAAS,GAAG,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC;QACnC,IAAM,SAAS,GAAG,OAAO,GAAG,CAAC,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/C,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,OAAO,GAAG,OAAO,CAAC;QACtB,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC3D,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;gBAC1D,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;gBACtC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;gBACtC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;gBACtC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;YACxC,CAAC;YACD,GAAG,IAAI,SAAS,CAAC;YACjB,OAAO,IAAI,SAAS,CAAC;YACrB,OAAO,IAAI,SAAS,CAAC;QACvB,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;QACb,IAAI,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,GAAG,GAAG,OAAO,GAAG,CAAC,CAAC;QACtB,IAAM,SAAS,GAAG,YAAY,GAAG,CAAC,CAAC;QACnC,IAAM,SAAS,GAAG,CAAC,GAAG,OAAO,CAAC;QAC9B,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC3D,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAC9B,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,UAAU,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YAC5C,GAAG,IAAI,SAAS,CAAC;YACjB,GAAG,IAAI,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,YAAY,GAAG,CAAC,CAAC;QACjD,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC;QAC/B,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;YAC1D,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;YAClC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC;YAClC,GAAG,IAAI,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAGD,EAAE,CAAC,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAlED,gEAkEC;;;;;ACvND;IAOE,wBAAoB,KAAmB;QAAnB,UAAK,GAAL,KAAK,CAAc;QAN/B,oBAAe,GAAG,CAAC,CAAC;QACpB,oBAAe,GAAG,CAAC,CAAC;QACpB,iBAAY,GAAsC,EAAE,CAAC;QACrD,eAAU,GAAG,KAAK,CAAC;QACnB,qBAAgB,GAA8B,EAAE,CAAC;IAEf,CAAC;IAE3C,uCAAc,GAAd,UAAe,OAAyB;QACtC,IAAM,QAAQ,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;QACjD,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACnC,CAAC;QACD,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAElC,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,GAAG,EAAE,CAAC;YACX,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAG,CAAC;QAC9C,CAAC;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,EAAE,CAAC;QAEX,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,uCAAc,GAAd,UAAe,OAAqB,EAAE,KAAuB;QAC3D,IAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;QAC/C,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,IAAI,CAAC,GAAG,EAAE,CAAC;IACb,CAAC;IAEO,4BAAG,GAAX;QACE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YACrB,MAAM,CAAC;QACT,CAAC;QACD,IAAM,KAAK,GAAG,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC1D,OAAO,CAAC,GAAG,CACP,WAAW,EAAE,IAAI,CAAC,eAAe,GAAG,KAAK,GAAG,IAAI,CAAC,eAAe,EAChE,MAAI,KAAK,MAAG,CAAC,CAAC;IACpB,CAAC;IAED,2CAAkB,GAAlB;QACE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,2CAAkB,GAAlB;QACE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,gCAAO,GAAP;QACE,GAAG,CAAC,CAAC,IAAM,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YACtC,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC5C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACzD,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9D,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACH,qBAAC;AAAD,CAtEA,AAsEC,IAAA;AAtEY,wCAAc;AAwE3B,gCAAgC,YAA8B;IAC5D,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;;;;;AC3ED,2CAA6C;AAK7C;IACE,MAAM,CAAC,qDAEN,CAAC;AACJ,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,aAAa,EAAE,CAAC,CAAC;AAC9D,CAAC;AAFD,gEAEC;AAED,aACI,KAAmB,EAAE,UAAwB,EAAE,CAAe,EAC9D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACnE,CAAC;AAJD,kBAIC;AAED,2BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;AAC9E,CAAC;AAHD,8CAGC;AAKD;IACE,MAAM,CAAC,wGAGN,CAAC;AACJ,CAAC;AAED;IACE,MAAM,CAAC,WAAW,CAAC,uBAAuB,CAAC,cAAc,EAAE,CAAC,CAAC;AAC/D,CAAC;AAFD,kEAEC;AAED,cACI,KAAmB,EAAE,WAAyB,EAAE,CAAe,EAC/D,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACpE,CAAC;AAJD,oBAIC;AAED,4BACI,CAAe,EAAE,IAAY,EAAE,OAAe;IAChD,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;AAC/E,CAAC;AAHD,gDAGC;;;;;AClDD,iDAA6C;AAE7C,iCAAwC,QAAgB;IACtD,MAAM,CAAC,+KAOD,QAAQ,YACV,CAAC;AACP,CAAC;AAVD,0DAUC;AAED,iBACI,KAAmB,EAAE,cAA4B,EAAE,CAAe,EAClE,IAAY,EAAE,OAAe,EAAE,MAAoB;IACrD,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACjC,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAPD,0BAOC;AAED,+BACI,CAAe,EAAE,IAAY,EAAE,OAAe,EAC9C,QAAgB;IAClB,IAAM,KAAK,GAAG,IAAI,4BAAY,EAAE,CAAC;IACjC,IAAM,iBAAiB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC5D,IAAM,OAAO,GAAiB,KAAK,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACrE,IAAM,QAAQ,GAAiB,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACxE,IAAM,aAAa,GAAiB,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7E,KAAK,CAAC,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACxD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;IAChE,IAAM,MAAM,GAAG,KAAK,CAAC,yBAAyB,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7E,KAAK,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IACzC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,CAAC,OAAO,EAAE,CAAC;IAChB,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAhBD,sDAgBC;;;;;ACvCD,IAAI,yBAAyB,GAAG,KAAK,CAAC;AACtC,IAAI,cAAc,GAAsB,IAAK,CAAC;AAC9C,IAAI,gBAAgB,GAAW,IAAK,CAAC;AAErC,iCAAmC;AAatB,QAAA,kBAAkB,GAAG,qEAIjC,CAAC;AAIF,qCAA4C,UAAkC;IAE5E,IAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;IACjB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAClB,MAAM,CAAC,qCAAqC,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACnE,CAAC;AAND,kEAMC;AAMD;IACE,yBAAyB,GAAG,KAAK,CAAC;IAClC,cAAc,GAAG,SAAS,CAAC;AAC7B,CAAC;AAHD,oCAGC;AAKD;IACE,yBAAyB,GAAG,IAAI,CAAC;IACjC,cAAc,GAAG,SAAS,CAAC;AAC7B,CAAC;AAHD,oCAGC;AAED;IACE,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC;QAC/B,MAAM,CAAC,KAAK,CAAC;IACf,CAAC;IAED,EAAE,CAAC,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC;QACjC,IAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAM,EAAE,GAAG,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC3C,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;YACf,cAAc,GAAG,IAAI,CAAC;YAEtB,IAAM,oBAAoB,GACtB,mBAAmB,CACf,EAA2B,EAAE,oBAAoB,CAC5B,CAAC;YAC9B,oBAAoB,CAAC,WAAW,EAAE,CAAC;QACrC,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,cAAc,GAAG,KAAK,CAAC;QACzB,CAAC;IACH,CAAC;IACD,MAAM,CAAC,cAAc,CAAC;AACxB,CAAC;AArBD,0CAqBC;AAED,+CACI,MAAyB,EACzB,UAAkC;IACpC,IAAI,EAAyB,CAAC;IAC9B,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QACtB,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAA0B,CAAC;IACxE,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,EAAE,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC;YACtC,MAAM,CAAC,UAAU,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAChC,CAAC;IAC5B,CAAC;IAED,EAAE,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,MAAM,CAAC,EAAE,CAAC;AACZ,CAAC;AAhBD,sFAgBC;AAED,sBAAgC,EAAyB,EAAE,IAAa;IACtE,IAAM,WAAW,GAAG,IAAI,EAAE,CAAC;IAC3B,eAAe,CAAC,EAAE,CAAC,CAAC;IACpB,MAAM,CAAC,WAAW,CAAC;AACrB,CAAC;AAJD,oCAIC;AAED,IAAI,8BAA8B,GAAG,KAAK,CAAC;AAE3C,uCAA8C,OAAgB;IAC5D,8BAA8B,GAAG,OAAO,CAAC;AAC3C,CAAC;AAFD,sEAEC;AAED,yBAAgC,EAAyB;IACvD,EAAE,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;QACnC,IAAM,KAAK,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC5B,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,eAAe,GAAG,oBAAoB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;AACH,CAAC;AAPD,0CAOC;AAED,8BACI,EAAyB,EAAE,MAAc;IAC3C,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACf,KAAK,EAAE,CAAC,QAAQ;YACd,MAAM,CAAC,UAAU,CAAC;QACpB,KAAK,EAAE,CAAC,YAAY;YAClB,MAAM,CAAC,cAAc,CAAC;QACxB,KAAK,EAAE,CAAC,aAAa;YACnB,MAAM,CAAC,eAAe,CAAC;QACzB,KAAK,EAAE,CAAC,iBAAiB;YACvB,MAAM,CAAC,mBAAmB,CAAC;QAC7B,KAAK,EAAE,CAAC,6BAA6B;YACnC,MAAM,CAAC,+BAA+B,CAAC;QACzC,KAAK,EAAE,CAAC,aAAa;YACnB,MAAM,CAAC,eAAe,CAAC;QACzB,KAAK,EAAE,CAAC,kBAAkB;YACxB,MAAM,CAAC,oBAAoB,CAAC;QAC9B;YACE,MAAM,CAAC,qBAAqB,GAAG,MAAM,CAAC;IAC1C,CAAC;AACH,CAAC;AApBD,oDAoBC;AAED,6BACI,EAAyB,EAAE,aAAqB;IAClD,MAAM,CAAC,WAAW,CACd,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,EAA9B,CAA8B,EACxC,aAAa,GAAG,aAAa,GAAG,kCAAkC,CAAC,CAAC;AAC1E,CAAC;AALD,kDAKC;AAED,4BACI,EAAyB,EAAE,kBAA0B;IACvD,IAAM,YAAY,GAAgB,WAAW,CACzC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,aAAa,CAAC,EAAjC,CAAiC,EAC3C,sCAAsC,CAAC,CAAC;IAC5C,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,kBAAkB,CAAC,EAAjD,CAAiD,CAAC,CAAC;IAC1E,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,EAA9B,CAA8B,CAAC,CAAC;IACvD,EAAE,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,YAAY,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;QACrE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;IACtD,CAAC;IACD,MAAM,CAAC,YAAY,CAAC;AACtB,CAAC;AAZD,gDAYC;AAED,8BACI,EAAyB,EAAE,oBAA4B;IACzD,IAAM,cAAc,GAAgB,WAAW,CAC3C,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,eAAe,CAAC,EAAnC,CAAmC,EAC7C,wCAAwC,CAAC,CAAC;IAC9C,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,oBAAoB,CAAC,EAArD,CAAqD,CAAC,CAAC;IAC9E,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,EAAhC,CAAgC,CAAC,CAAC;IACzD,EAAE,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,cAAc,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;QACvE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IACD,MAAM,CAAC,cAAc,CAAC;AACxB,CAAC;AAZD,oDAYC;AAED,uBAA8B,EAAyB;IACrD,MAAM,CAAC,WAAW,CACd,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,EAAE,EAAlB,CAAkB,EAAE,gCAAgC,CAAC,CAAC;AACtE,CAAC;AAHD,sCAGC;AAED,qBAA4B,EAAyB,EAAE,OAAqB;IAC1E,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,EAAvB,CAAuB,CAAC,CAAC;IAChD,EAAE,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;QAC9D,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;AACH,CAAC;AAND,kCAMC;AAED,yBACI,EAAyB,EAAE,OAAqB;IAClD,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,EAA3B,CAA2B,CAAC,CAAC;IACpD,EAAE,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;QAClE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;AACH,CAAC;AAPD,0CAOC;AAED,kCACI,EAAyB,EAAE,IAAkB;IAC/C,IAAM,MAAM,GAAgB,WAAW,CACnC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,EAAE,EAAjB,CAAiB,EAAE,8BAA8B,CAAC,CAAC;IACjE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,EAAtC,CAAsC,CAAC,CAAC;IAC/D,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,EAApD,CAAoD,CAAC,CAAC;IAC7E,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAPD,4DAOC;AAED,iCACI,EAAyB,EAAE,IAAiB;IAC9C,IAAM,MAAM,GAAgB,WAAW,CACnC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,YAAY,EAAE,EAAjB,CAAiB,EAAE,8BAA8B,CAAC,CAAC;IACjE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,oBAAoB,EAAE,MAAM,CAAC,EAA9C,CAA8C,CAAC,CAAC;IACvE,YAAY,CACR,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,EAA5D,CAA4D,CAAC,CAAC;IAC5E,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AARD,0DAQC;AAED,6BAAoC,EAAyB;IAC3D,EAAE,CAAC,CAAC,gBAAgB,IAAI,IAAI,CAAC,CAAC,CAAC;QAC7B,MAAM,CAAC,gBAAgB,CAAC;IAC1B,CAAC;IACD,gBAAgB;QACZ,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAG,CAAC,YAAY,CAAC,EAAG,CAAC,gBAAgB,CAAC,EAAtC,CAAsC,CAAC,CAAC;IACnE,MAAM,CAAC,gBAAgB,CAAC;AAC1B,CAAC;AAPD,kDAOC;AAED;IACE,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QACtB,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IACD,MAAM,CAAC,CAAC,CAAC;AACX,CAAC;AALD,sDAKC;AAED,uBAA8B,EAAyB;IACrD,MAAM,CAAC,WAAW,CACd,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,EAAE,EAAlB,CAAkB,EAAE,gCAAgC,CAAC,CAAC;AACtE,CAAC;AAHD,sCAGC;AAED,6BACI,EAAyB,EAAE,KAAa,EAAE,MAAc;IAC1D,IAAM,cAAc,GAAW,mBAAmB,CAAC,EAAE,CAAC,CAAC;IACvD,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,IAAM,SAAS,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,SAAS,GAAG,cAAc,CAAC,CAAC;IAC1E,CAAC;IACD,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;QAC1D,IAAM,SAAS,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC;QACnD,IAAM,GAAG,GAAG,GAAG,GAAG,cAAc,GAAG,GAAG,GAAG,cAAc,GAAG,GAAG,CAAC;QAC9D,MAAM,IAAI,KAAK,CACX,yBAAyB,GAAG,SAAS;YACrC,oDAAoD,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;IACxE,CAAC;AACH,CAAC;AAdD,kDAcC;AAED,2BAAkC,EAAyB;IACzD,MAAM,CAAC,WAAW,CACd,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,iBAAiB,EAAE,EAAtB,CAAsB,EAAE,oCAAoC,CAAC,CAAC;AAC9E,CAAC;AAHD,8CAGC;AAED,4CACI,EAAyB,EAAE,OAAqB,EAAE,SAAiB,EACnE,MAAmB,EAAE,mBAA2B,EAAE,iBAAyB,EAC3E,iBAAyB;IAC3B,IAAM,GAAG,GAAG,EAAE,CAAC,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACrD,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACf,IAAM,KAAK,GAAG,IAAI,KAAK,CACnB,2BAA2B,GAAG,SAAS,GAAG,oBAAoB,CAAC,CAAC;QAEnE,KAAa,CAAC,4BAA4B,GAAG,SAAS,CAAC;QACxD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,EAAtC,CAAsC,CAAC,CAAC;IAC/D,YAAY,CACR,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,mBAAmB,CACxB,GAAG,EAAE,mBAAmB,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAC5D,iBAAiB,CAAC,EAFhB,CAEgB,CAAC,CAAC;IAC5B,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,uBAAuB,CAAC,GAAG,CAAC,EAA/B,CAA+B,CAAC,CAAC;AAC1D,CAAC;AAnBD,gFAmBC;AAED,yBACI,EAAyB,EAAE,OAAqB,EAAE,WAAmB;IACvE,mBAAmB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,QAAQ,GAAG,WAAW,CAAC,EAA3C,CAA2C,CAAC,CAAC;IACpE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAtC,CAAsC,CAAC,CAAC;AACjE,CAAC;AALD,0CAKC;AAED,2BACI,EAAyB,EAAE,WAAmB;IAChD,mBAAmB,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,QAAQ,GAAG,WAAW,CAAC,EAA3C,CAA2C,CAAC,CAAC;IACpE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAnC,CAAmC,CAAC,CAAC;AAC9D,CAAC;AALD,8CAKC;AAED,0CACI,EAAyB,EAAE,OAAqB,EAChD,WAAmB;IACrB,MAAM,CAAC,WAAW,CACd,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,EAA3C,CAA2C,EACrD,WAAW,GAAG,WAAW,GAAG,2BAA2B,CAAC,CAAC;AAC/D,CAAC;AAND,4EAMC;AAED,4CACI,EAAyB,EAAE,OAAqB,EAAE,OAAqB,EACvE,kBAA0B,EAAE,WAAmB;IACjD,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE,WAAW,CAAC,EAAzC,CAAyC,CAAC,CAAC;IAClE,IAAM,eAAe,GACjB,gCAAgC,CAAC,EAAE,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC;IACtE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,SAAS,CAAC,eAAe,EAAE,WAAW,CAAC,EAA1C,CAA0C,CAAC,CAAC;AACrE,CAAC;AAPD,gFAOC;AAED,iCAAwC,EAAyB;IAC/D,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,EAAxC,CAAwC,CAAC,CAAC;IACjE,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAApD,CAAoD,CAAC,CAAC;IAC7E,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAnD,CAAmD,CAAC,CAAC;AAC9E,CAAC;AAJD,0DAIC;AAED,uCACI,EAAyB,EAAE,OAAqB,EAChD,WAA6B;IAC/B,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,EAA/C,CAA+C,CAAC,CAAC;IACxE,YAAY,CACR,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,oBAAoB,CACzB,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,iBAAiB,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC,EAD9D,CAC8D,CAAC,CAAC;AAC5E,CAAC;AARD,sEAQC;AAED,2CACI,EAAyB,EAAE,WAA6B;IAC1D,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,EAA/C,CAA+C,CAAC,CAAC;IACxE,YAAY,CACR,EAAE,EACF,cAAM,OAAA,EAAE,CAAC,oBAAoB,CACzB,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,iBAAiB,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAD3D,CAC2D,CAAC,CAAC;AACzE,CAAC;AAPD,8EAOC;AAED,6BAAoC,EAAyB;IAC3D,IAAM,MAAM,GAAG,EAAE,CAAC,sBAAsB,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC;IACzD,EAAE,CAAC,CAAC,MAAM,KAAK,EAAE,CAAC,oBAAoB,CAAC,CAAC,CAAC;QACvC,MAAM,IAAI,KAAK,CACX,6BAA6B,GAAG,0BAA0B,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9E,CAAC;AACH,CAAC;AAND,kDAMC;AAED,oCACI,EAAyB,EAAE,MAAc;IAC3C,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACf,KAAK,EAAE,CAAC,iCAAiC;YACvC,MAAM,CAAC,mCAAmC,CAAC;QAC7C,KAAK,EAAE,CAAC,yCAAyC;YAC/C,MAAM,CAAC,2CAA2C,CAAC;QACrD,KAAK,EAAE,CAAC,iCAAiC;YACvC,MAAM,CAAC,mCAAmC,CAAC;QAC7C,KAAK,EAAE,CAAC,uBAAuB;YAC7B,MAAM,CAAC,yBAAyB,CAAC;QACnC;YACE,MAAM,CAAC,gBAAgB,GAAG,MAAM,CAAC;IACrC,CAAC;AACH,CAAC;AAdD,gEAcC;AAED,qBACI,EAAyB,EAAE,aAA6B,EACxD,cAAsB;IACxB,IAAM,OAAO,GAAW,YAAY,CAAC,EAAE,EAAE,cAAM,OAAA,aAAa,EAAE,EAAf,CAAe,CAAC,CAAC;IAChE,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;IAClC,CAAC;IACD,MAAM,CAAC,OAAY,CAAC;AACtB,CAAC;AAED,6BAA6B,EAAyB,EAAE,WAAmB;IACzE,IAAM,cAAc,GAAG,EAAE,CAAC,gCAAgC,GAAG,CAAC,CAAC;IAC/D,IAAM,aAAa,GAAG,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC;IAChD,EAAE,CAAC,CAAC,aAAa,GAAG,EAAE,CAAC,QAAQ,IAAI,aAAa,GAAG,cAAc,CAAC,CAAC,CAAC;QAClE,IAAM,gBAAgB,GAAG,0BAA0B,GAAG,cAAc,GAAG,GAAG,CAAC;QAC3E,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,gBAAgB,GAAG,GAAG,CAAC,CAAC;IACtE,CAAC;AACH,CAAC;AAED,yCACI,EAAyB,EAAE,YAAsB,EACjD,iBAAoC;IACtC,IAAM,UAAU,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAC;IAC3C,IAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;IAC9C,EAAE,CAAC,CAAC,iBAAiB,IAAI,IAAI,CAAC,CAAC,CAAC;QAC9B,IAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,CACP,IAAI,KAAK,aAAa,EACtB,oBAAkB,IAAI,0BAAuB;aACzC,qBAAmB,aAAa,MAAG,CAAA,CAAC,CAAC;QAC7C,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,UAAU;YAClC,iBAAiB,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC;YACvC,MAAM,CAAC,iBAAiB,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC;QACnD,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CACN,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,UAAU;QAC1D,YAAY,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC;QAClC,MAAM,CAAC,YAAgC,CAAC;IAC1C,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CACN,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,UAAU;QAC1D,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC;QACpD,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;AACH,CAAC;AA9BD,0EA8BC;;;;;AClZD,iCAAsX;AACtX,yCAA2C;AAC3C,iCAA8B;AAC9B,uCAAoC;AACpC,mDAAgD;AAChD,2CAAwC;AACxC,iDAAgD;AAChD,uCAAoC;AACpC,yEAA0E;AAC1E,6DAAwD;AACxD,iCAA8B;AAC9B,+DAA2D;AAC3D,iCAA8B;AAC9B,uCAAoC;AACpC,2CAAuC;AACvC,2CAAwC;AAExC,+CAA2C;AAC3C,yCAAsC;AACtC,yCAA+D;AAC/D,qCAAkC;AAClC,2CAAwC;AAExC,4BAAmC,KAAa;IAC9C,IAAM,GAAG,GAAgB,EAAE,CAAC;IAC5B,KAAK,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAArD,CAAqD,CAAC,CAAC;IAC7E,MAAM,CAAC,GAAG,CAAC;AACb,CAAC;AAJD,gDAIC;AAED,wBAAwB,IAAU;IAChC,EAAE,CAAC,CAAC,IAAI,YAAY,mBAAW,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,CAAC,IAAI,iBAAO,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,kBAAU,CAAC,CAAC,CAAC;QACtC,IAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAU,CAAC,EAAE,CAAC,CAAC;QACtC,IAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAU,CAAC,EAAE,CAAC,CAAC;QACtC,MAAM,CAAC,CAAC,IAAI,eAAM,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,yBAAiB,CAAC,CAAC,CAAC;QAC7C,IAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,yBAAiB,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,yBAAiB,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,yBAAiB,CAAC,CAAC,CAAC,CAAC;QAC3C,MAAM,CAAC,CAAC,IAAI,2BAAa,CACrB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,EACnE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACrB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,mBAAW,CAAC,CAAC,CAAC;QACvC,IAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAW,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,CAAC,CAAC,IAAI,kBAAO,CACf,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAClE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,eAAO,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,CAAC,IAAI,SAAG,CAAC,IAAI,CAAC,MAAM,CAAC,eAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,eAAO,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,CAAC,IAAI,SAAG,CAAC,IAAI,CAAC,MAAM,CAAC,eAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,gBAAQ,CAAC,CAAC,CAAC;QACpC,MAAM,CAAC,CAAC,IAAI,8BAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,gBAAQ,CAAC,CAAC,CAAC;QACpC,MAAM,CAAC,CAAC,IAAI,8BAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,mBAAW,CAAC,CAAC,CAAC;QACvC,MAAM,CAAC,CAAC,IAAI,iCAAO,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,mCAA2B,CAAC,CAAC,CAAC;QACvD,IAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,mCAA2B,CAAC,CAAC,CAAC,CAAC;QACrD,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,mCAA2B,CAAC,MAAM,CAAC,CAAC;QAC/D,MAAM,CAAC,CAAC,IAAI,iCAAuB,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,mBAAW,CAAC,CAAC,CAAC;QACvC,MAAM,CAAC,CAAC,IAAI,iBAAO,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,2BAAmB,CAAC,CAAC,CAAC;QAC/C,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,2BAAmB,CAAC,KAAK,CAAC,CAAC;QACrD,IAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,2BAAmB,CAAC,UAAU,CAAC,CAAC;QAC/D,MAAM,CAAC,CAAC,IAAI,mCAAe,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,wBAAgB,CAAC,CAAC,CAAC;QAC5C,MAAM,CAAC,CAAC,IAAI,2BAAY,CACpB,IAAI,CAAC,MAAM,CAAC,wBAAgB,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,wBAAgB,CAAC,EAAE,CAAC,EAClE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,kBAAU,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,CAAC,IAAI,eAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,kCAA0B,CAAC,CAAC,CAAC;QACtD,MAAM,CAAC,CAAC,IAAI,sCAAiB,CACzB,IAAI,CAAC,MAAM,CAAC,kCAA0B,CAAC,EAAE,CAAC,EAC1C,IAAI,CAAC,MAAM,CAAC,kCAA0B,CAAC,EAAE,CAAC,EAC1C,IAAI,CAAC,MAAM,CAAC,kCAA0B,CAAC,EAAE,CAAC,EAC1C,IAAI,CAAC,MAAM,CAAC,kCAA0B,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,oBAAY,CAAC,CAAC,CAAC;QACxC,MAAM,CAAC,CAAC,IAAI,mBAAQ,CAChB,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,IAAI,EACrE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,kBAAU,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,CAAC,IAAI,gCAAM,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,eAAO,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,CAAC,IAAI,SAAG,CACX,IAAI,CAAC,MAAM,CAAC,eAAO,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,eAAO,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACtE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,oBAAY,CAAC,CAAC,CAAC;QACxC,MAAM,CAAC,CAAC,IAAI,mBAAQ,CAChB,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAC1D,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,oBAAY,CAAC,CAAC,CAAC;QACxC,MAAM,CAAC,CAAC,IAAI,mBAAQ,CAChB,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,oBAAY,CAAC,EAAE,CAAC,EAC1D,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,kBAAU,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,CAAC,IAAI,eAAM,CACd,IAAI,CAAC,MAAM,CAAC,kBAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,kBAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,iBAAS,CAAC,CAAC,CAAC;QACrC,MAAM,CAAC,CAAC,IAAI,aAAK,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7D,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,qBAAa,CAAC,CAAC,CAAC;QACzC,MAAM,CAAC,CAAC,IAAI,sBAAS,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAa,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;IAAC,IAAI,CAAC,CAAC;QAEN,MAAM,KAAK,CAAC,yBAAyB,GAAI,IAAI,CAAC,WAAmB,CAAC,IAAI,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;;;;;;;;;;;;;;;AC5GD,0CAA4C;AAE5C,2CAAgD;AAEhD,8BAAgC;AAEhC,2BAA+B;AAK/B;IAAyB,uBAAS;IAIhC,aACY,QAAgB,EAAU,QAAgB,EAC1C,OAAe;QAF3B,YAGE,iBAAO,SAOR;QATW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,aAAO,GAAP,OAAO,CAAQ;QAEzB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EACpD,2DAA2D;YACvD,gBAAgB,CAAC,CAAC;;IAC5B,CAAC;IAED,yBAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAeC;QAdC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAI,MAAe,CAAC;YACpB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACxC,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACxC,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC5B,CAAC;YACD,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAkCC;QA/BC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACzB,EAAE,CAAC,CAAC,KAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;wBAC9B,KAAI,CAAC,YAAY,GAAG,gBAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;oBAC1C,CAAC;oBACD,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,KAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAChE,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACzB,EAAE,CAAC,CAAC,KAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;wBAC9B,KAAI,CAAC,YAAY,GAAG,gBAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;oBAC1C,CAAC;oBACD,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,KAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAChE,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,qBAAO,GAAP;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IACH,UAAC;AAAD,CA1EA,AA0EC,CA1EwB,cAAS,GA0EjC;AA1EY,kBAAG;;;;;;;;;;;;;;;ACNhB,2BAA+B;AAK/B;IAA4B,0BAAS;IAInC,gBAAoB,OAAe,EAAU,OAAe;QAA5D,YACE,iBAAO,SACR;QAFmB,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;;IAE5D,CAAC;IAED,4BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAKC;QAJC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAChC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IACH,aAAC;AAAD,CApBA,AAoBC,CApB2B,cAAS,GAoBpC;AApBY,wBAAM;;;;;;;;;;;;;;;ACLnB,2BAA+B;AAK/B;IAAkC,gCAAS;IAIzC,sBACY,QAAgB,EAAU,QAAgB,EAC1C,OAAe;QAF3B,YAGE,iBAAO,SACR;QAHW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,aAAO,GAAP,OAAO,CAAQ;;IAE3B,CAAC;IAED,kCAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAMC;QALC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,+BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAChC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;IACH,mBAAC;AAAD,CAvBA,AAuBC,CAvBiC,cAAS,GAuB1C;AAvBY,oCAAY;;;;;;;;;;;;;;;ACVzB,qDAAuD;AAMvD,2BAA+B;AAK/B;IAA8B,4BAAS;IAMrC,kBACY,QAAgB,EAAU,QAAgB,EAAU,IAAY,EAChE,OAAe;QAF3B,YAGE,iBAAO,SAGR;QALW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAAU,UAAI,GAAJ,IAAI,CAAQ;QAChE,aAAO,GAAP,OAAO,CAAQ;QAEzB,aAAa,CAAC,yBAAyB,CACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;;IAC5C,CAAC;IAED,8BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAQC;QAPC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAY,CAAC;QACzD,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAY,CAAC;QAEzD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;YACtD,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,2BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAChC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IACH,eAAC;AAAD,CA7BA,AA6BC,CA7B6B,cAAS,GA6BtC;AA7BY,4BAAQ;;;;;;;;;;;;;;;ACXrB,6CAA+C;AAI/C,8BAAgC;AAEhC,2BAA+B;AAK/B;IAAmC,iCAAS;IAiB1C,uBACY,OAAe,EAAU,OAAe,EAAU,OAAe,EACjE,OAAe,EAAU,SAAiB,EAC1C,WAAmB,EAAU,MAAU,EAAE,OAAgB;QAA5B,uBAAA,EAAA,UAAU;QAHnD,YAIE,iBAAO,SAWR;QAdW,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;QACjE,aAAO,GAAP,OAAO,CAAQ;QAAU,eAAS,GAAT,SAAS,CAAQ;QAC1C,iBAAW,GAAX,WAAW,CAAQ;QAAU,YAAM,GAAN,MAAM,CAAI;QAEjD,KAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvC,KAAI,CAAC,OAAO,GAAG,OAAO,IAAI,IAAI;YAC1B,OAAO;YACP,SAAS,CAAC,iBAAiB,CACvB,KAAI,CAAC,OAAO,CAAC,KAAiC,EAAE,KAAI,CAAC,SAAS,EAC9D,KAAI,CAAC,MAAM,CAAC,CAAC;QACrB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,KAAK,CAAC,KAAI,CAAC,OAAO,CAAC,EACxB,uBAAqB,KAAI,CAAC,OAAO,sCAAmC;YAChE,mCAAmC,CAAC,CAAC;;IAC/C,CAAC;IAED,mCAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAUC;QATC,IAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAC7D,IAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAC5D,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAEvD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gCAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAcC;QAXC,IAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAC7D,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QACvD,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAEvD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACR,IAAA,qEAC4D,EAD3D,UAAE,EAAE,UAAE,EAAE,UAAE,CACkD;YACnE,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YAC3C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YAC3C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,0CAAkB,GAA1B,UAA2B,YAAsB;QAC/C,IAAI,CAAC,MAAM,CACP,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS;YAC9B,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS;YAClC,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;YACzC,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,WAAW,EACxC,+BAA6B,IAAI,CAAC,SAAS,SAAI,IAAI,CAAC,SAAS,MAAG;aACzD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,SAAI,IAAI,CAAC,WAAW,sBAAmB,CAAA;aAC/D,YAAU,YAAY,MAAG,CAAA,CAAC,CAAC;IACrC,CAAC;IACH,oBAAC;AAAD,CAxEA,AAwEC,CAxEkC,cAAS,GAwE3C;AAxEY,sCAAa;;;;;;;;;;;;;;;ACX1B,0CAA4C;AAI5C,8BAAgC;AAEhC,2BAA+B;AAK/B;IAA4B,0BAAS;IAOnC,gBACY,QAAgB,EAAU,QAAgB,EAC1C,OAAe;QAF3B,YAGE,iBAAO,SAOR;QATW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,aAAO,GAAP,OAAO,CAAQ;QAEzB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EACpD,2DAA2D;YACvD,gBAAgB,CAAC,CAAC;;IAC5B,CAAC;IAED,4BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAeC;QAdC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAI,MAAe,CAAC;YACpB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC7C,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC7C,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC/B,CAAC;YACD,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAiDC;QA9CC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAChD,IAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEhD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACf,IAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;oBAEhC,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;oBAEvD,GAAG,CAAC,OAAO,EAAE,CAAC;gBAChB,CAAC;gBAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACtB,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC9D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC/D,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAE7C,IAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAE9C,IAAI,eAAe,SAAS,CAAC;gBAC7B,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACf,eAAe,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;gBAC7D,CAAC;gBAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACtB,eAAe,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;gBAC7D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,eAAe,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;gBAC/C,CAAC;gBAED,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBACtC,IAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;gBAEvD,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACf,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;gBACvE,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBAC7D,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,aAAC;AAAD,CAtFA,AAsFC,CAtF2B,cAAS,GAsFpC;AAtFY,wBAAM;;;;;;;;;;;;;;;ACXnB,qEAA6G;AAK7G,2BAA+B;AAK/B;IAA2C,yCAAS;IAClD,+BACc,OAAe,EAAY,OAAe,EAC5C,IAAwB;QAFpC,YAGE,iBAAO,SACR;QAHa,aAAO,GAAP,OAAO,CAAQ;QAAY,aAAO,GAAP,OAAO,CAAQ;QAC5C,UAAI,GAAJ,IAAI,CAAoB;;IAEpC,CAAC;IAED,2CAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAMC;QALC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wCAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAcC;QATC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAM,IAAI,GAAG,KAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACvC,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IACH,4BAAC;AAAD,CA9BA,AA8BC,CA9B0C,cAAS,GA8BnD;AA9BY,sDAAqB;AAmClC;IAA0B,wBAAqB;IAC7C,cAAY,OAAe,EAAE,OAAe;eAC1C,kBAAM,OAAO,EAAE,OAAO,EAAE,IAAI,+BAAQ,EAAE,CAAC;IACzC,CAAC;IACH,WAAC;AAAD,CAJA,AAIC,CAJyB,qBAAqB,GAI9C;AAJY,oBAAI;AASjB;IAA0B,wBAAqB;IAC7C,cAAY,OAAe,EAAE,OAAe;eAC1C,kBAAM,OAAO,EAAE,OAAO,EAAE,IAAI,+BAAQ,EAAE,CAAC;IACzC,CAAC;IACH,WAAC;AAAD,CAJA,AAIC,CAJyB,qBAAqB,GAI9C;AAJY,oBAAI;AASjB;IAA6B,2BAAqB;IAChD,iBAAY,OAAe,EAAE,OAAe;eAC1C,kBAAM,OAAO,EAAE,OAAO,EAAE,IAAI,kCAAW,EAAE,CAAC;IAC5C,CAAC;IACH,cAAC;AAAD,CAJA,AAIC,CAJ4B,qBAAqB,GAIjD;AAJY,0BAAO;AASpB;IAA4B,0BAAqB;IAC/C,gBAAY,OAAe,EAAE,OAAe;eAC1C,kBAAM,OAAO,EAAE,OAAO,EAAE,IAAI,iCAAU,EAAE,CAAC;IAC3C,CAAC;IACH,aAAC;AAAD,CAJA,AAIC,CAJ2B,qBAAqB,GAIhD;AAJY,wBAAM;;;;;;;;;;;;;;;ACxEnB,0CAA4C;AAC5C,yDAA+E;AAE/E,2CAAyD;AAEzD,8BAAgC;AAEhC,2BAA+B;AAK/B;IAAwD,mCAAS;IAG/D,yBACc,QAAgB,EAAY,QAAgB,EAC5C,OAAe,EAAY,IAA6B;QAFtE,YAGE,iBAAO,SAER;QAJa,cAAQ,GAAR,QAAQ,CAAQ;QAAY,cAAQ,GAAR,QAAQ,CAAQ;QAC5C,aAAO,GAAP,OAAO,CAAQ;QAAY,UAAI,GAAJ,IAAI,CAAyB;QAEpE,KAAI,CAAC,cAAc,GAAG,gBAAM,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;;IAC3E,CAAC;IAED,qCAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAUC;QATC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAM,eAAe,GAAG,KAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YACrD,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YACtC,IAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YAC/D,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kCAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAcC;QAXC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC;YACD,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAO,GAAP;QACE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IACH,sBAAC;AAAD,CA1CA,AA0CC,CA1CuD,cAAS,GA0ChE;AA1CY,0CAAe;AA+C5B;IAAqC,mCAAwB;IAC3D,yBAAY,QAAgB,EAAE,QAAgB,EAAE,OAAe;eAC7D,kBAAM,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,+BAAc,EAAE,CAAC;IAC1D,CAAC;IACH,sBAAC;AAAD,CAJA,AAIC,CAJoC,eAAe,GAInD;AAJY,0CAAe;;;;;;;;;;;;;;;AC3D5B,0CAA4C;AAM5C,2BAA+B;AAK/B;IAAyB,uBAAS;IAIhC,aAAoB,OAAe,EAAU,OAAe;QAA5D,YACE,iBAAO,SACR;QAFmB,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;;IAE5D,CAAC;IAED,yBAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAMC;QALC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAWC;QARC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC5C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACrE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,UAAC;AAAD,CA5BA,AA4BC,CA5BwB,cAAS,GA4BjC;AA5BY,kBAAG;;;;;;;;;;;;;;;ACXhB,0CAA4C;AAM5C,2BAA+B;AAK/B;IAAuC,qCAAS;IAO9C,2BACY,QAAgB,EAAU,QAAgB,EAC1C,QAAgB,EAAU,QAAgB,EAC1C,SAAiB;QAH7B,YAIE,iBAAO,SACR;QAJW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,eAAS,GAAT,SAAS,CAAQ;;IAE7B,CAAC;IAED,uCAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAUC;QATC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;QACzD,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;QAEzD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,oCAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBA4BC;QAzBC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACzE,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;YACzE,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAChD,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACjE,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAChD,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACjE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,wBAAC;AAAD,CAvDA,AAuDC,CAvDsC,cAAS,GAuD/C;AAvDY,8CAAiB;;;;;;;;;;;;;;;ACX9B,0CAA4C;AAM5C,2BAA+B;AAK/B;IAAyB,uBAAS;IAIhC,aAAoB,OAAe,EAAU,OAAe;QAA5D,YACE,iBAAO,SACR;QAFmB,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;;IAE5D,CAAC;IAED,yBAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAMC;QALC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAWC;QARC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC5C,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7D,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,UAAC;AAAD,CA5BA,AA4BC,CA5BwB,cAAS,GA4BjC;AA5BY,kBAAG;;;;;;;;;;;;;;;ACXhB,0CAA4C;AAC5C,qCAA4D;AAK5D,2BAA+B;AAK/B;IAA4B,0BAAS;IACnC,gBACY,QAAgB,EAAU,QAAgB,EAC1C,OAAe;QAF3B,YAGE,iBAAO,SACR;QAHW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,aAAO,GAAP,OAAO,CAAQ;;IAE3B,CAAC;IAED,4BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAkBC;QAjBC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;gBACnD,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAa,EAAE,EAAa,CAAC,CAAC,CAAC,CAAC;YACrE,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC1D,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAa,EAAE,EAAa,CAAC,CAAC,CAAC,CAAC;YAClE,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC1D,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAa,EAAE,EAAa,CAAC,CAAC,CAAC,CAAC;YAClE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAqCC;QAlCC,IAAI,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE1C,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YAC1B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;YAC9B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAChC,CAAC;QACD,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;YAC1B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;YAC9B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YAId,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CACnB,EAAa,EAAE,EAAa,EAAE,wBAAiB,CAAC,OAAO,EACvD,wBAAiB,CAAC,UAAU,CAAC,CAAC;gBAClC,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EACb,IAAI,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACjE,CAAC;YACD,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CACnB,EAAa,EAAE,EAAa,EAAE,wBAAiB,CAAC,UAAU,EAC1D,wBAAiB,CAAC,OAAO,CAAC,CAAC;gBAC/B,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EACb,IAAI,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACjE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,aAAC;AAAD,CAjEA,AAiEC,CAjE2B,cAAS,GAiEpC;AAjEY,wBAAM;;;;;;;;;;;;;;;ACXnB,6CAA+C;AAI/C,8BAAgC;AAEhC,2BAA+B;AAK/B;IAA6B,2BAAS;IAGpC,iBACY,OAAe,EAAU,OAAe,EACxC,SAAiB,EAAU,MAAU,EAAE,GAAY;QAAxB,uBAAA,EAAA,UAAU;QAFjD,YAGE,iBAAO,SAcR;QAhBW,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;QACxC,eAAS,GAAT,SAAS,CAAQ;QAAU,YAAM,GAAN,MAAM,CAAI;QAG/C,EAAE,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC;YAChB,KAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACjB,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,KAAI,CAAC,GAAG,GAAG,SAAS,CAAC,iBAAiB,CAClC,OAAO,CAAC,KAAiC,EAAE,KAAI,CAAC,SAAS,EACzD,KAAI,CAAC,MAAM,CAAC,CAAC;QACnB,CAAC;QAED,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,KAAK,CAAC,KAAI,CAAC,GAAG,CAAC,EACpB,uBAAqB,KAAI,CAAC,GAAG,sCAAmC;YAC5D,mCAAmC,CAAC,CAAC;;IAC/C,CAAC;IAED,6BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAOC;QANC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QACvD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,KAAI,CAAC,SAAS,EAAE,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAYC;QATC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QACvD,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAY,CAAC;QAEvD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,CAAC,eAAe,CACrB,EAAE,EAAE,CAAC,EAAE,KAAI,CAAC,SAAS,EAAE,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC;IACH,cAAC;AAAD,CA5CA,AA4CC,CA5C4B,cAAS,GA4CrC;AA5CY,0BAAO;;;;;;;;;;;;;;;ACXpB,0CAA4C;AAI5C,8BAAgC;AAEhC,2BAA+B;AAK/B;IAA8B,4BAAS;IAKrC,kBACY,QAAgB,EAAU,QAAgB,EAC1C,OAAe;QAF3B,YAGE,iBAAO,SAOR;QATW,cAAQ,GAAR,QAAQ,CAAQ;QAAU,cAAQ,GAAR,QAAQ,CAAQ;QAC1C,aAAO,GAAP,OAAO,CAAQ;QAEzB,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EACpD,2DAA2D;YACvD,gBAAgB,CAAC,CAAC;;IAC5B,CAAC;IAED,8BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAeC;QAdC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAI,MAAe,CAAC;YACpB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACzC,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACzC,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACvC,CAAC;YACD,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,2BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAoCC;QAjCC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;oBAExC,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAEzD,CAAC;gBAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACxC,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC1D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvE,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;oBAExC,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAEzD,CAAC;gBAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACxC,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC1D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvE,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,eAAC;AAAD,CAvEA,AAuEC,CAvE6B,cAAS,GAuEtC;AAvEY,4BAAQ;;;;;ACLrB;IAAA;IAYA,CAAC;IAJC,0CAAsB,GAAtB,UACI,eAA+B,EAAE,cAA8B,IAAG,CAAC;IAEvE,2BAAO,GAAP,cAAW,CAAC;IACd,gBAAC;AAAD,CAZA,AAYC,IAAA;AAZqB,8BAAS;;;;;;;;;;;;;;;ACN/B,0CAA4C;AAE5C,2CAAwC;AAExC,8BAAgC;AAEhC,2BAA+B;AAK/B;IAA+B,6BAAS;IAEtC,mBAAoB,CAAS,EAAU,SAAiB;QAAxD,YACE,iBAAO,SAER;QAHmB,OAAC,GAAD,CAAC,CAAQ;QAAU,eAAS,GAAT,SAAS,CAAQ;QAEtD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;;IAC9C,CAAC;IAID,+BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAMC;QALC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEtC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,4BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAgBC;QAbC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvC,MAAM,CAAC;QACT,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,SAAS,CAAC,CAAC;YAC9C,EAAE,CAAC,CAAC,KAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC;gBACtB,IAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,CAAC,CAAC,CAAC;gBAC3C,KAAI,CAAC,IAAI,GAAG,iBAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBACtC,KAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,CAAC;YACD,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACL,CAAC;IACH,gBAAC;AAAD,CAlCA,AAkCC,CAlC8B,cAAS,GAkCvC;AAlCY,8BAAS;;;;;;;;;;;;;;;ACRtB,8BAAgC;AAEhC,2BAA+B;AAE/B;IAAqE,2BAAS;IAC5E,iBAAoB,OAAe,EAAU,OAAe;QAA5D,YACE,iBAAO,SAMR;QAPmB,aAAO,GAAP,OAAO,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAQ;QAE1D,IAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAChD,IAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAChD,IAAI,CAAC,MAAM,CACP,KAAK,KAAK,KAAK,EACf,qBAAmB,KAAK,2BAAsB,KAAK,iBAAc,CAAC,CAAC;;IACzE,CAAC;IAED,6BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAOC;QANC,IAAM,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAO,CAAC;QAElD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAS,CAAC,EAAE,KAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBASC;QANC,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAO,CAAC;QAElD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAS,EAAE,EAAE,KAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IACH,cAAC;AAAD,CA7BA,AA6BC,CA7BoE,cAAS,GA6B7E;AA7BY,0BAAO;;;;;;;;;;;;;;;ACRpB,kCAAgC;AAEhC,2CAAyD;AAEzD,8BAAgC;AAEhC,2BAA+B;AAE/B;IAA6B,2BAAS;IACpC,iBAAoB,YAAoB,EAAU,MAAc;QAAhE,YACE,iBAAO,SACR;QAFmB,kBAAY,GAAZ,YAAY,CAAQ;QAAU,YAAM,GAAN,MAAM,CAAQ;;IAEhE,CAAC;IAED,6BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAKC;QAJC,IAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAY,CAAC;QACjE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACrB,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0BAAQ,GAAR;QACE,MAAM,KAAK,CAAC,yCAAyC,CAAC,CAAC;IACzD,CAAC;IACH,cAAC;AAAD,CAfA,AAeC,CAf4B,cAAS,GAerC;AAfY,0BAAO;AAiBpB;IAA6C,2CAAS;IACpD,iCACY,YAAoB,EAAU,WAAmB,EACjD,OAAe;QAF3B,YAGE,iBAAO,SAER;QAJW,kBAAY,GAAZ,YAAY,CAAQ;QAAU,iBAAW,GAAX,WAAW,CAAQ;QACjD,aAAO,GAAP,OAAO,CAAQ;QAwCnB,aAAO,GAAG,gBAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAtCjC,KAAI,CAAC,aAAa,GAAG,IAAI,cAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;;IACtD,CAAC;IAED,6CAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAYC;QAXC,IAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAY,CAAC;QACjE,IAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAY,CAAC;QAE/D,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAE3C,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC7D,eAAe,CAAC,GAAG,CACf,KAAI,CAAC,OAAO,EACZ,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0CAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBASC;QANC,IAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACxD,IAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEpD,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wDAAsB,GAAtB,UACI,eAA+B,EAAE,cAA8B;QACjE,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACnD,CAAC;IAED,yCAAO,GAAP;QACE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;IAIH,8BAAC;AAAD,CA5CA,AA4CC,CA5C4C,cAAS,GA4CrD;AA5CY,0DAAuB;AA8CpC,0BACI,IAAiB,EAAE,CAAU,EAAE,MAAe,EAAE,OAAe;IACjE,IAAI,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,EAAE,6CAA6C,CAAC,CAAC;IAE3E,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;QAChB,IAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QAClD,IAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC5D,IAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;AACL,CAAC;AAZD,4CAYC;;;;;;;;;;;;;;;AClFD,0CAA4C;AAI5C,8BAAgC;AAEhC,2BAA+B;AAM/B;IAA2B,yBAAS;IAClC,eAAoB,KAAa,EAAU,OAAiB;QAA5D,YACE,iBAAO,SAIR;QALmB,WAAK,GAAL,KAAK,CAAQ;QAAU,aAAO,GAAP,OAAO,CAAU;QAE1D,OAAO,CAAC,OAAO,CAAC,UAAA,MAAM;YACpB,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;;IACL,CAAC;IAED,2BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAC5D,IAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAA,MAAM;YACzB,eAAe,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wBAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAiBC;QAdC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3C,MAAM,CAAC;QACT,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CACb,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EACnC,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEzC,KAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,UAAA,MAAM;gBAClC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;YACH,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC;IACH,YAAC;AAAD,CAjCA,AAiCC,CAjC0B,cAAS,GAiCnC;AAjCY,sBAAK;;;;;;;;;;;;;;;ACZlB,0CAA4C;AAE5C,2CAAgD;AAEhD,8BAAgC;AAEhC,2BAA+B;AAE/B;IAA8B,4BAAS;IAOrC,kBACY,EAAU,EAAU,EAAU,EAAU,SAAiB;QADrE,YAEE,iBAAO,SAOR;QARW,QAAE,GAAF,EAAE,CAAQ;QAAU,QAAE,GAAF,EAAE,CAAQ;QAAU,eAAS,GAAT,SAAS,CAAQ;QAEnE,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YAC9B,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;YAClC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EACxC,2DAA2D;YACvD,gBAAgB,CAAC,CAAC;;IAC5B,CAAC;IAED,8BAAW,GAAX,UAAY,IAAiB,EAAE,eAA+B;QAA9D,iBAeC;QAdC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAExC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,IAAI,MAAe,CAAC;YACpB,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACzC,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACzC,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC5B,CAAC;YACD,eAAe,CAAC,GAAG,CAAC,KAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,2BAAQ,GAAR,UACI,IAAiB,EAAE,eAA+B,EAClD,cAA8B;QAFlC,iBAmCC;QAhCC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxC,IAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxC,IAAM,EAAE,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE9C,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACtC,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACzB,EAAE,CAAC,CAAC,KAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;wBAC9B,KAAI,CAAC,YAAY,GAAG,gBAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;oBAC1C,CAAC;oBACD,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,KAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC1D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YAED,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,KAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACtC,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACzB,IAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC7B,EAAE,CAAC,CAAC,KAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;wBAC9B,KAAI,CAAC,YAAY,GAAG,gBAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;oBAC1C,CAAC;oBACD,cAAc,CAAC,GAAG,CACd,KAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,KAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC7D,CAAC;gBAAC,IAAI,CAAC,CAAC;oBACN,cAAc,CAAC,GAAG,CAAC,KAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAClD,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0BAAO,GAAP;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IACH,eAAC;AAAD,CA7EA,AA6EC,CA7E6B,cAAS,GA6EtC;AA7EY,4BAAQ;;;;;ACJrB;IAIE,mBAAY,qBAA8B;QACxC,EAAE,CAAC,CAAC,qBAAqB,IAAI,IAAI,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,sBAAsB,GAAG,qBAAuC,CAAC;QACxE,CAAC;IACH,CAAC;IAkBH,gBAAC;AAAD,CA1BA,AA0BC,IAAA;AA1BqB,8BAAS;;;;;ACC/B,wBAAkC,CAAI,EAAE,CAAI;IAC1C,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACZ,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACjB,MAAM,CAAC,CAAC,CAAC,CAAC;IACZ,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AARD,wCAQC;AAyBD;IASE,uBACY,UAAyB,EACzB,aAAgC;QADhC,eAAU,GAAV,UAAU,CAAe;QACzB,kBAAa,GAAb,aAAa,CAAmB;QAVpC,SAAI,GAAQ,EAAE,CAAC;IAUwB,CAAC;IAMhD,+BAAO,GAAP,UAAQ,CAAI;QACV,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACpC,CAAC;IAOD,+BAAO,GAAP;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,IAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAChB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACjB,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAWD,8BAAM,GAAN,UAAO,IAAO,EAAE,KAAa;QAG3B,IAAM,IAAI,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC9C,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACV,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAChB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YAOV,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC;IAMD,6BAAK,GAAL;QACE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;IAChC,CAAC;IAEO,sCAAc,GAAtB,UAAuB,CAAI,EAAE,QAAgB;QAC3C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IASO,sCAAc,GAAtB,UAAuB,KAAa;QAClC,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;YAChB,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,CAAC;IAEO,yCAAiB,GAAzB,UAA0B,KAAa;QACrC,IAAM,SAAS,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IAEO,0CAAkB,GAA1B,UAA2B,KAAa;QACtC,IAAM,SAAS,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IAEO,mCAAW,GAAnB,UAAoB,KAAa;QAC/B,IAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC/C,EAAE,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACvB,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC;QACD,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC;QACrB,CAAC;QACD,MAAM,CAAC,CAAC,CAAC,CAAC;IACZ,CAAC;IAEO,8BAAM,GAAd,UAAe,KAAa;QAC1B,IAAI,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC5B,KAAK,GAAG,SAAS,CAAC;YAClB,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAEO,qCAAa,GAArB,UAAsB,KAAa;QACjC,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9B,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC;QACD,IAAI,iBAAiB,GAAG,KAAK,CAAC;QAC9B,IAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QACrD,EAAE,CAAC,CAAC,CAAC,cAAc,KAAK,CAAC,CAAC,CAAC;YACvB,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1D,iBAAiB,GAAG,cAAc,CAAC;QACrC,CAAC;QACD,IAAM,eAAe,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACvD,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,CAAC,CAAC,CAAC;YACxB,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3D,iBAAiB,GAAG,eAAe,CAAC;QACtC,CAAC;QACD,MAAM,CAAC,CAAC,iBAAiB,KAAK,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,iBAAiB,CAAC;IAChE,CAAC;IAEO,gCAAQ,GAAhB,UAAiB,KAAa;QAC5B,IAAI,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC5B,KAAK,GAAG,SAAS,CAAC;YAClB,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAEO,+BAAO,GAAf,UAAgB,MAAc,EAAE,MAAc;QAC5C,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,CAAC;IAEO,4BAAI,GAAZ,UAAa,CAAS,EAAE,CAAS;QAC/B,IAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IACH,oBAAC;AAAD,CAxKA,AAwKC,IAAA;AAxKY,sCAAa;;;;;ACnC1B,0CAA+C;AAC/C,uDAAyD;AAGzD,6CAA+C;AAC/C,uDAAkD;AAClD,6BAA+B;AAmB/B;IAOE,wBAAY,WAAyB;QAArC,iBAIC;QAVD,SAAI,GAAoC,EAAE,CAAC;QAOzC,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;YAChB,WAAW,CAAC,OAAO,CAAC,UAAA,KAAK,IAAI,OAAA,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,KAAK,EAAlC,CAAkC,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IACH,qBAAC;AAAD,CAZA,AAYC,IAAA;AAZY,wCAAc;AAc3B,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,iDAAI,CAAA;IACJ,+CAAG,CAAA;IACH,iDAAI,CAAA;AACN,CAAC,EAJW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAIxB;AASD;IAKE,iBAAoB,KAAY,EAAU,IAAiB;QAAvC,UAAK,GAAL,KAAK,CAAO;QAAU,SAAI,GAAJ,IAAI,CAAa;QAmM3D,uBAAkB,GAAG,IAAI,iCAAc,EAAE,CAAC;QAE1C,qBAAgB,GAAG,IAAI,iCAAc,EAAE,CAAC;QAChC,iBAAY,GAAoC,EAAE,CAAC;QAInD,cAAS,GAAG,gBAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IA1M4B,CAAC;IAK/D,yBAAO,GAAP;QAAA,iBAaC;QAZC,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC;QAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,UAAA,GAAG;YACxC,IAAM,OAAO,GAAG,KAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YACvC,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;gBACvB,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,OAAO,EAAE,EAAZ,CAAY,CAAC,CAAC;YACjD,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,EAAE,CAAC,CAAC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,CAAC,CAAC;YACjC,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;QACjC,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAYD,yBAAO,GAAP,UAAQ,OAAiB,EAAE,WAAwB;QAAnD,iBA2BC;QA1BC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YACrB,IAAM,IAAI,GAAG,IAAI,cAAc,CAAC,WAAW,CAAC,CAAC;YAC7C,IAAM,OAAO,GAAG,KAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAEvD,IAAM,WAAW,GAAG,KAAI,CAAC,kBAAkB,CAAC;YAE5C,YAAY,CAAC,oCAAoC,CAC7C,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAChC,YAAY,CAAC,+BAA+B,CACxC,OAAO,CAAC,UAAU,EAAE,KAAI,CAAC,kBAAkB,EAAE,KAAI,CAAC,gBAAgB,CAAC,CAAC;YAExE,YAAY,CAAC,mCAAmC,CAC5C,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAChC,YAAY,CAAC,4CAA4C,CACrD,IAAI,EAAE,WAAW,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;YAElC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,WAAW,CAAC,KAAI,CAAC,IAAI,EAAE,WAAW,CAAC,EAAtC,CAAsC,CAAC,CAAC;YAEzE,IAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAlB,CAAkB,CAAC,CAAC;YACrD,OAAO,CAAC,OAAO,CAAC,UAAA,CAAC,IAAI,OAAA,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAArB,CAAqB,CAAC,CAAC;YAE5C,YAAY,CAAC,6CAA6C,CACtD,IAAI,EAAE,WAAW,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;YAElC,MAAM,CAAC,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAC;IAWD,sBAAI,GAAJ,UAAK,MAAc,EAAE,WAAwB;QAC3C,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAiBD,uBAAK,GAAL,UACI,UAAkB,EAAE,WAAwB,EAAE,SAAiB,EAC/D,SAAoB,EAAE,aAAkC;QAF5D,iBA6DC;QA3DyB,8BAAA,EAAA,gBAAgB,aAAa,CAAC,IAAI;QAC1D,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,EACpC,kDAAkD,CAAC,CAAC;QAExD,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;YAC/B,IAAI,CAAC,eAAe,GAAG,gBAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/C,CAAC;QAED,IAAM,IAAI,GAAG,IAAI,cAAc,CAAC,WAAW,CAAC,CAAC;QAC7C,YAAY,CAAC,qCAAqC,CAAC,IAAI,CAAC,CAAC;QAEzD,IAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC;QAC5D,IAAM,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;QAC/C,IAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC;QAChE,IAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAC5C,IAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACxC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAE1C,YAAY,CAAC,mCAAmC,CAC5C,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAEhC,SAAS,CAAC,WAAW,CACjB,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QAE3D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI,EAAE,KAAK;YACjC,IAAI,IAAI,GAAG,KAAK,CAAC,gBAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAEhC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,EAAE,CAAC,EAAE,CAAC;gBACnC,YAAY,CAAC,oCAAoC,CAC7C,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;gBAChC,YAAY,CAAC,2CAA2C,CACpD,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;gBAC9B,YAAY,CAAC,+BAA+B,CACxC,OAAO,CAAC,UAAU,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;gBAEhD,YAAY,CAAC,4CAA4C,CACrD,IAAI,EAAE,WAAW,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,mBAAmB,CAAC,OAAO,CACvB,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,WAAW,CAAC,KAAI,CAAC,IAAI,EAAE,WAAW,CAAC,EAAtC,CAAsC,CAAC,CAAC;gBAClD,kBAAkB,CAAC,OAAO,CACtB,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,QAAQ,CAAC,KAAI,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,CAAC,EAA9C,CAA8C,CAAC,CAAC;gBAE1D,SAAS,CAAC,YAAY,CAAC,KAAI,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;gBAEnE,YAAY,CAAC,6CAA6C,CACtD,IAAI,EAAE,WAAW,EAAE,KAAI,CAAC,IAAI,CAAC,CAAC;gBAElC,IAAI,GAAG,KAAI,CAAC,oBAAoB,CAC5B,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,CAAC;YACxD,CAAC;YAED,SAAS,CAAC,UAAU,CAChB,KAAI,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;YAE3D,MAAM,CAAC,KAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,sCAAoB,GAA5B,UACI,SAAiB,EAAE,QAAgB,EACnC,aAA4B;QAC9B,EAAE,CAAC,CAAC,aAAa,KAAK,aAAa,CAAC,IAAI;YACpC,aAAa,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,CAAC,SAAS,CAAC;IACnB,CAAC;IAEO,oCAAkB,GAA1B,UAA2B,SAAiB,EAAE,aAA4B;QAExE,EAAE,CAAC,CAAC,aAAa,KAAK,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;YACzC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,CAAC,SAAS,CAAC;IACnB,CAAC;IAEO,oCAAkB,GAA1B,UAA2B,OAAiB,EAAE,IAAoB;QAEhE,IAAM,GAAG,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACpD,IAAI,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACrC,EAAE,CAAC,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC;YAC1B,IAAI,KAAK,GACL,YAAY,CAAC,qCAAqC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAItE,KAAK,GAAG,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAC1C,YAAY,CAAC,0CAA0C,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACrE,YAAY,CAAC,iDAAiD,CAAC,KAAK,CAAC,CAAC;YACtE,IAAM,UAAU,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAC/D,OAAO,GAAG,EAAC,KAAK,OAAA,EAAE,UAAU,YAAA,EAAC,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;QACnC,CAAC;QAED,MAAM,CAAC,OAAO,CAAC;IACjB,CAAC;IAEO,qCAAmB,GAA3B,UAA4B,OAAiB,EAAE,IAAoB;QACjE,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,EAAE,EAAJ,CAAI,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI;YACjD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9C,CAAC;IAWH,cAAC;AAAD,CAhNA,AAgNC,IAAA;AAhNY,0BAAO;;;;;ACxDpB,iCAA6F;AAC7F,yCAA2C;AAG3C,0CAAuC;AAIvC,6BAA+B;AAW/B,+CACI,cAA8B;IAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;SAClC,GAAG,CAAC,UAAA,QAAQ,IAAI,OAAA,cAAc,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,EAA1C,CAA0C,CAAC,CAAC;AACnE,CAAC;AAJD,sFAIC;AAWD,+CACI,WAAqB,EAAE,cAA8B;IACvD,IAAM,gBAAgB,GAClB,qCAAqC,CAAC,cAAc,CAAC,CAAC;IAC1D,IAAM,SAAS,GAAG,WAAW,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,IAAI,EAAN,CAAM,CAAC,CAAC;IAC/C,IAAM,sBAAsB,GACxB,UAAU,CAAC,yBAAyB,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IACtE,IAAM,oBAAoB,GACtB,UAAU,CAAC,uBAAuB,CAAC,sBAAsB,CAAC,CAAC;IAC/D,MAAM,CAAC,oBAAoB,CAAC;AAC9B,CAAC;AAVD,sFAUC;AAWD,6CACI,aAAqB,EAAE,cAA8B;IACvD,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI;QACxB,EAAE,CAAC,CAAC,IAAI,YAAY,oBAAY,IAAI,IAAI,YAAY,oBAAY,CAAC,CAAC,CAAC;YACjE,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAPD,kFAOC;AAKD,2CAAkD,aAAqB;IAErE,IAAM,KAAK,GAAmB,EAAE,CAAC;IACjC,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI;QACxB,EAAE,CAAC,CAAC,IAAI,YAAY,oBAAY,CAAC,CAAC,CAAC;YACjC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC;AACf,CAAC;AATD,8EASC;AAKD,+CACI,cAA8B;IAChC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,QAAQ;QAC/C,EAAE,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,YAAY,iBAAO,CAAC,CAAC,CAAC;YAC3D,MAAM,IAAI,KAAK,CACX,+DAA+D;gBAC/D,mBAAmB,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AATD,sFASC;AAKD,sDACI,SAAyB,EAAE,WAA2B,EAAE,IAAiB;IAC3E,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,QAAQ;QAC1C,IAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;QAE5C,IAAI,IAAa,CAAC;QAClB,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,YAAY,iBAAO,CAAC,CAAC,CAAC;YACtC,IAAI,GAAG,SAAS,CAAC,IAAe,CAAC;QACnC,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,IAAM,QAAQ,GAAG,SAAS,CAAC,IAAqB,CAAC;YACjD,IAAI,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,CAAC,MAAM,CACP,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EACpD,uDAAqD,IAAI,CAAC,KAAK,MAAG;aAC9D,gCAA8B,SAAS,CAAC,MAAM,CAAC,EAAE,cAAW,CAAA;aACzD,SAAS,CAAC,MAAM,CAAC,KAAK,MAAG,CAAA,CAAC,CAAC;QACtC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;AACL,CAAC;AApBD,oGAoBC;AAMD,uDACI,SAAyB,EAAE,WAA2B,EAAE,IAAiB;IAC3E,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,QAAQ;QAC1C,IAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;QAE5C,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,YAAY,iBAAO,CAAC,CAAC,CAAC,CAAC;YACzC,IAAM,QAAQ,GAAG,SAAS,CAAC,IAAqB,CAAC;YAEjD,IAAM,cAAc,GAAG,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACzD,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QAC7C,CAAC;QAED,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC;AAdD,sGAcC;AAYD,oDACI,cAA8B,EAAE,aAAqB;IACvD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC;QAChC,IAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAC9B,EAAE,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;YAChD,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7B,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,EAAE,CAAC,CAAC;QACN,CAAC;IACH,CAAC;AACH,CAAC;AAXD,gGAWC;AAUD,8CACI,aAAqB,EAAE,cAA8B;IACvD,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI;QACxB,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;gBACxD,cAAc,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC3C,CAAC;YACD,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAVD,oFAUC;AAUD,qDACI,aAAqB,EAAE,SAAyB;IAClD,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI;QACxB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,UAAA,SAAS;YACxC,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACrC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;gBACpE,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAChC,CAAC;YACD,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAXD,kGAWC;AAYD,yCACI,UAAuB,EAAE,WAA2B,EACpD,SAAyB;IAC3B,UAAU,CAAC,OAAO,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,sBAAsB,CAAC,WAAW,EAAE,SAAS,CAAC,EAAjD,CAAiD,CAAC,CAAC;AAC9E,CAAC;AAJD,0EAIC;AAUD,2DACI,aAAqB;IACvB,aAAa,CAAC,OAAO,CAAC,UAAA,IAAI;QACxB,EAAE,CAAC,CAAC,IAAI,YAAY,uBAAe,CAAC,CAAC,CAAC;YACpC,IAAM,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;YACvD,MAAM,IAAI,KAAK,CACX,oBAAoB,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,KAAK;gBAC/C,kCAAkC,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAVD,8GAUC;AASD,uBAA8B,KAAa;IACzC,IAAM,oBAAoB,GAAa,EAAE,CAAC;IAC1C,IAAM,iBAAiB,GAAkC,EAAE,CAAC;IAG5D,KAAK,CAAC,OAAO,CAAC,UAAA,IAAI;QAChB,IAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,CAAC,UAAA,GAAG;YACd,IAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACrC,IAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC;YAC/B,EAAE,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;gBAC3C,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;YACrC,CAAC;YACD,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YACjC,EAAE,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC;gBAClC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;gBACxC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,iBAAS,CAAC,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YACxE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAQH,IAAM,QAAQ,GAAW,EAAE,CAAC;IAC5B,KAAK,CAAC,OAAO,CAAC,UAAA,IAAI;QAChB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,iBAAiB,CAAC,CAAC,CAAC;YACjC,IAAM,SAAS,GAAG,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC7C,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3B,CAAC;QACD,IAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,CAAC,UAAA,GAAG;YACd,IAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACrC,IAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,EAAE,CAAC,CAAC,OAAO,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBACjC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC,kBAAkB,EAAE,CAAC;YACrE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,QAAQ,CAAC;AAClB,CAAC;AA5CD,sCA4CC;;;;;;;;;;;;;;;AC9RD,0CAA+C;AAC/C,yCAAsC;AAEtC,6CAA+C;AAC/C,uDAAkD;AAElD;IAAkC,gCAAS;IACzC,sBAAoB,YAAoB,EAAE,qBAA8B;QAAxE,YACE,kBAAM,qBAAqB,CAAC,SAC7B;QAFmB,kBAAY,GAAZ,YAAY,CAAQ;QAgEhC,uBAAiB,GAAG,IAAI,iCAAc,EAAE,CAAC;QAEzC,SAAG,GAAG,gBAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;IAhE5B,CAAC;IAED,kCAAW,GAAX,UACI,IAAiB,EAAE,SAAiB,EAAE,OAAuB,EAC7D,kBAAkC,EAAE,gBAAgC;QAFxE,iBAaC;QAVC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,sBAAsB,IAAI,IAAI;YACpD,YAAY,CAAC,iCAAiC,CAAC,OAAO,CAAC,KAAK,CAAC;YAC7D,IAAI,CAAC,sBAAsB,CAAC;QAChC,EAAE,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;YAC/B,IAAI,CAAC,CAAC,GAAG,gBAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,OAAO,CACtB,UAAA,IAAI,IAAI,OAAA,KAAI,CAAC,iBAAiB,CAAC,GAAG,CAC9B,IAAI,CAAC,MAAM,EAAE,iBAAO,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAD1C,CAC0C,CAAC,CAAC;IAC1D,CAAC;IAED,mCAAY,GAAZ,UACI,IAAiB,EAAE,OAAuB,EAC1C,kBAAkC,EAAE,gBAAgC;QAFxE,iBAYC;QATC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,KAAI,CAAC,aAAc,CAAC,OAAO,CAAC,UAAA,IAAI;gBAC9B,IAAM,QAAQ,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACnD,IAAM,mBAAmB,GAAG,KAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACpE,KAAI,CAAC,iBAAiB,CAAC,GAAG,CACtB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;gBAChE,mBAAmB,CAAC,OAAO,EAAE,CAAC;YAChC,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAU,GAAV,UACI,IAAiB,EAAE,SAAiB,EAAE,OAAuB,EAC7D,kBAAkC,EAAE,gBAAgC;QAFxE,iBAkBC;QAfC,IAAI,CAAC,KAAK,CAAC,UAAC,IAAI;YACd,KAAI,CAAC,aAAc,CAAC,OAAO,CAAC,UAAA,IAAI;gBAC9B,IAAM,WAAW,GAAG,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACxD,IAAM,QAAQ,GAAG,KAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACzD,IAAM,QAAQ,GACV,IAAI,CAAC,cAAc,CAAC,KAAI,CAAC,CAAE,EAAE,QAAQ,EAAE,KAAI,CAAC,GAAI,EAAE,WAAW,CAAC,CAAC;gBACnE,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACpD,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;gBAErB,WAAW,CAAC,OAAO,EAAE,CAAC;YACxB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,iCAAc,EAAE,CAAC;IAChD,CAAC;IAED,8BAAO,GAAP;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;YACnB,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IACrB,CAAC;IAED,sCAAe,GAAf,UAAgB,YAAoB;QAClC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAMH,mBAAC;AAAD,CArEA,AAqEC,CArEiC,qBAAS,GAqE1C;AArEY,oCAAY;;;;;ACAzB;IAAA;QAkFU,SAAI,GAAyC,EAAE,CAAC;IAC1D,CAAC;IA7EC,4BAAG,GAAH,UAAI,MAAc,EAAE,KAAmB;QACrC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;IAC/B,CAAC;IAUD,4BAAG,GAAH,UAAI,MAAc,EAAE,UAAkB;QAAlB,2BAAA,EAAA,kBAAkB;QACpC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,EAAE,GAAG,oBAAoB,CAAC,CAAC;QAChE,CAAC;QACD,IAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACjC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,EAAE,GAAG,kBAAkB,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,CAAC,GAAI,CAAC;IACd,CAAC;IAMD,+BAAM,GAAN,UAAO,MAAc;QACnB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,qCAAY,GAAZ,UAAa,MAAc;QACzB,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;YACvC,MAAM,CAAC;QACT,CAAC;QACD,IAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACjC,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC;YACjB,MAAM,CAAC;QACT,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,CAAC;QACd,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IAC9B,CAAC;IAKD,6BAAI,GAAJ;QACE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IACvC,CAAC;IAKD,gCAAO,GAAP;QAAA,iBAQC;QAPC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,QAAQ;YACrC,IAAM,GAAG,GAAG,KAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;YACjC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACR,GAAG,CAAC,OAAO,EAAE,CAAC;YAChB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;IAQD,qCAAY,GAAZ,UAAa,MAAc;QACzB,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,EAAE,GAAG,oBAAoB,CAAC,CAAC;QAChE,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACvC,CAAC;IAGH,qBAAC;AAAD,CAnFA,AAmFC,IAAA;AAnFY,wCAAc;;;;;ACH3B,iBAAwB,KACY;IAClC,IAAI,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC;IAC3B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,OAAO,OAAO,GAAG,CAAC,EAAE,CAAC;QAEnB,KAAK,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAEtC,OAAO,EAAE,CAAC;QAEV,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACtB,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9B,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACtB,CAAC;AACH,CAAC;AAhBD,0BAgBC;AAGD,eAAsB,GAAW,EAAE,CAAS,EAAE,GAAW;IACvD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACzC,CAAC;AAFD,sBAEC;AAGD,qBAA4B,CAAS,EAAE,CAAS;IAC9C,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC;AAFD,kCAEC;AAQD,mBAA0B,IAAQ,EAAE,MAAU,EAAE,SAAiB;IAAvC,qBAAA,EAAA,QAAQ;IAAE,uBAAA,EAAA,UAAU;IAAE,0BAAA,EAAA,iBAAiB;IAC/D,IAAI,EAAU,EAAE,EAAU,EAAE,CAAS,CAAC;IACtC,GAAG,CAAC;QACF,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IACxB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;IAEhB,IAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IACpD,EAAE,CAAC,CAAC,SAAS,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IACD,MAAM,CAAC,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;AAChC,CAAC;AAbD,8BAaC;AAGD,qBAA4B,CAAS,EAAE,CAAS;IAC9C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,IAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACzB,MAAM,IAAI,IAAI,GAAG,IAAI,CAAC;IACxB,CAAC;IACD,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAPD,kCAOC;AAED,gBAAuB,IAAa,EAAE,GAAW;IAC/C,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAJD,wBAIC;AAED,2BACI,MAAgB,EAAE,MAAgB,EAAE,kBAAuB;IAAvB,mCAAA,EAAA,uBAAuB;IAC7D,MAAM,CACF,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,kBAAkB,IAAG,YAAU,MAAM,aAAQ,MAAM,gBAAa,CAAA,CAAC,CAAC;AACxE,CAAC;AALD,8CAKC;AAGD,iBAAwB,GAAU,EAAE,GAAc;IAChD,GAAG,GAAG,CAAC,GAAG,KAAK,SAAS,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;IACrC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;QACpC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACvB,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,MAAM,CAAC,GAAG,CAAC;AACb,CAAC;AAVD,0BAUC;AAID,oBAA2B,GAAc;IACvC,IAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,OAAO,GAAG,YAAY,KAAK,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACvB,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACf,CAAC;IACD,MAAM,CAAC,KAAK,CAAC;AACf,CAAC;AAPD,gCAOC;AAED,uBAA8B,KAAe;IAC3C,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;QAEvB,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IACD,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACpB,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IACD,MAAM,CAAC,IAAI,CAAC;AACd,CAAC;AAVD,sCAUC;AAED,uBAA8B,KAAe;IAC3C,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC5B,CAAC;AAFD,sCAEC;AAGD,qBAA4B,EAAsB,EAAE,EAAsB;IACxE,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5B,MAAM,CAAC,KAAK,CAAC;IACf,CAAC;IACD,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpB,MAAM,CAAC,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,MAAM,CAAC,IAAI,CAAC;AACd,CAAC;AAVD,kCAUC;AAED,eAAsB,CAAS;IAC7B,MAAM,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC;AAFD,sBAEC;AAED,cAAqB,CAAS;IAE5B,EAAE,CAAC,CAAE,IAAY,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC;QAE/B,MAAM,CAAE,IAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,EAAE,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;QACnB,MAAM,CAAC,CAAC,CAAC;IACX,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC3B,MAAM,CAAC,CAAC,CAAC,CAAC;IACZ,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5B,MAAM,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC;AAdD,oBAcC;AAED,6BAAoC,IAAY;IAC9C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QACrD,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACnB,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AACnB,CAAC;AAPD,kDAOC;AAED,+BAAsC,CAAS;IAC7C,IAAM,eAAe,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;IAC3C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAC3B,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,CAAC,eAAe,CAAC,CAAC;IACzB,MAAM,CAAC,eAAe,CAAC;AACzB,CAAC;AAPD,sDAOC","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-footer'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-header'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport '../ndarray-image-visualizer';\nimport '../demo-header';\nimport '../demo-footer';\n\nimport {Array1D, CheckpointLoader, Graph, NDArray, NDArrayInitializer, NDArrayMath, NDArrayMathGPU, Scalar, Session, Tensor} from '../learnjs';\nimport {NDArrayImageVisualizer} from '../ndarray-image-visualizer';\n// tslint:disable-next-line:no-unused-variable\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\n\nconst GOOGLE_CLOUD_STORAGE_DIR =\n    'https://storage.googleapis.com/learnjs-data/checkpoint_zoo/';\n\n// tslint:disable-next-line:variable-name\nexport let FontEmbeddingPolymer = PolymerElement({\n  is: 'font-embedding',\n  properties: {\n    char: String,\n    fontId: String,\n    embedding: Array,\n    numberOfValidChars: {type: Number, value: 62, readonly: true},\n  }\n});\n\nexport interface EmbeddingDimSettings {\n  val: number;\n  init: number;\n}\n\nexport class FontEmbedding extends FontEmbeddingPolymer {\n  private variables: {[varName: string]: NDArray};\n\n  // Embedding dimension settings for the sliders\n  embedding: EmbeddingDimSettings[];\n\n  // Mapping of characters to the ID for the one-hot in the model.\n  charIdMap: {[char: string]: number};\n\n  // Font ID string from the paper-input.\n  fontId: string;\n\n  // Character string from the paper-input.\n  char: string;\n\n  graph: Graph;\n  session: Session;\n  inputTensor: Tensor;\n  outputTensor: Tensor;\n  math: NDArrayMath;\n  vis: NDArrayImageVisualizer;\n  numberOfValidChars: number;\n\n  ready() {\n    const checkpointLoader =\n        new CheckpointLoader(GOOGLE_CLOUD_STORAGE_DIR + 'fonts/');\n    checkpointLoader.getAllVariables().then(variables => {\n      this.variables = variables;\n      this.buildModel();\n      this.infer(this.fontId, this.char);\n    });\n\n    // Set up character ID mapping.\n    this.charIdMap = {};\n    for (let i = 65; i < 91; i++) {\n      this.charIdMap[String.fromCharCode(i)] = i - 65;\n    }\n    for (let i = 97; i < 123; i++) {\n      this.charIdMap[String.fromCharCode(i)] = i - 97 + 26;\n    }\n    for (let i = 48; i < 58; i++) {\n      this.charIdMap[String.fromCharCode(i)] = i - 48 + 52;\n    }\n    this.fontId = '0';\n    this.char = 'A';\n\n    const fontIdElement = this.querySelector('#font-id') as HTMLInputElement;\n    fontIdElement.addEventListener('change', (e) => {\n      this.fontId = fontIdElement.value;\n      this.newFontId(this.fontId);\n      this.infer(this.fontId, this.char);\n    });\n\n    const charIdElement = this.querySelector('#char-id') as HTMLInputElement;\n    charIdElement.addEventListener('change', (e) => {\n      this.char = charIdElement.value;\n      this.infer(this.fontId, this.char);\n    });\n  }\n\n  newFontId(fontId: string) {\n    // Ignore invalid IDs and no-op before weights loaded.\n    if (fontId.length === 0 || +fontId < 0 || +fontId > 56443) {\n      return;\n    }\n\n    // Load up embeddings for the selected font.\n    const embedding: EmbeddingDimSettings[] = [];\n    const embeddingNDArray =\n        this.variables['input_from_feature_columns/font_embedding/weights'];\n    for (let i = 0; i < embeddingNDArray.shape[1]; i++) {\n      const num = embeddingNDArray.get(+fontId, i);\n      embedding.push({init: num, val: num});\n    }\n    // tslint:disable-next-line:no-any\n    (this as any).set('embedding', embedding);\n  }\n\n  sliderChange(e: Event) {\n    const element = e.target as PolymerHTMLElement;\n    const index = parseInt(element.getAttribute('data-index')!, 10);\n    // tslint:disable-next-line:no-any\n    this.embedding[index].val = (element as any).immediateValue;\n    // Cause inference once a slider changes.\n    this.infer(this.fontId, this.char);\n  }\n\n  buildModel() {\n    this.vis = this.$.vis as NDArrayImageVisualizer;\n    this.vis.setShape([64, 64]);\n    this.vis.setSize(128, 128);\n\n    this.newFontId(this.fontId);\n\n    const fc1wName = 'Stack/fully_connected_1/weights';\n    const fc1bName = 'Stack/fully_connected_1/biases';\n    const fc2wName = 'Stack/fully_connected_2/weights';\n    const fc2bName = 'Stack/fully_connected_2/biases';\n    const fc3wName = 'Stack/fully_connected_3/weights';\n    const fc3bName = 'Stack/fully_connected_3/biases';\n    const fc4wName = 'Stack/fully_connected_4/weights';\n    const fc4bName = 'Stack/fully_connected_4/biases';\n    const fc5wName = 'fully_connected/weights';\n    const fc5bName = 'fully_connected/biases';\n\n    this.graph = new Graph();\n    const g = this.graph;\n    this.inputTensor = g.placeholder('input', [102]);\n\n    const relu1 = g.layers.dense(\n        'fc1', this.inputTensor, this.variables[fc1bName].shape[1],\n        (x) => g.relu(x), true,\n        new NDArrayInitializer(this.variables[fc1wName]),\n        new NDArrayInitializer(this.variables[fc1bName]));\n    const relu2 = g.layers.dense(\n        'fc2', relu1, this.variables[fc2bName].shape[1], (x) => g.relu(x), true,\n        new NDArrayInitializer(this.variables[fc2wName]),\n        new NDArrayInitializer(this.variables[fc2bName]));\n    const relu3 = g.layers.dense(\n        'fc3', relu2, this.variables[fc3bName].shape[1], (x) => g.relu(x), true,\n        new NDArrayInitializer(this.variables[fc3wName]),\n        new NDArrayInitializer(this.variables[fc3bName]));\n    const relu4 = g.layers.dense(\n        'fc4', relu3, this.variables[fc4bName].shape[1], (x) => g.relu(x), true,\n        new NDArrayInitializer(this.variables[fc4wName]),\n        new NDArrayInitializer(this.variables[fc4bName]));\n    this.outputTensor = g.layers.dense(\n        'fc5', relu4, this.variables[fc5bName].shape[1], (x) => g.sigmoid(x),\n        true, new NDArrayInitializer(this.variables[fc5wName]),\n        new NDArrayInitializer(this.variables[fc5bName]));\n\n    this.math = new NDArrayMathGPU();\n    this.session = new Session(g, this.math);\n  }\n\n  infer(fontId: string, char: string) {\n    if (fontId.length === 0 || +fontId < 0 || +fontId > 56443 ||\n        char.length === 0) {\n      return;\n    }\n    const charId = this.charIdMap[char.charAt(0)];\n    if (charId == null) {\n      return;\n    }\n\n    const onehot = Array.apply(null, Array(this.numberOfValidChars))\n                       .map(Number.prototype.valueOf, 0);\n    onehot[charId] = 1;\n    // TODO: Use slice here so we don't have to keep reuploading the embedding.\n    const embedding =\n        this.embedding.map((settings: EmbeddingDimSettings) => settings.val);\n\n    this.math.scope((keep, track) => {\n      const inputData = track(Array1D.new(embedding.concat(onehot)));\n\n      const infer = this.session.eval(\n          this.outputTensor, [{tensor: this.inputTensor, data: inputData}]);\n\n      // Convert the inferred tensor to the proper scaling for display then draw\n      // it.\n      const scalar = track(Scalar.new(255));\n      const scaled = this.math.scalarTimesArray(scalar, infer);\n      const adjusted = this.math.scalarMinusArray(scalar, scaled);\n      this.vis.saveImageDataFromNDArray(adjusted.as3D(64, 64, 1));\n      this.vis.draw();\n    });\n  }\n}\ndocument.registerElement(FontEmbedding.prototype.is, FontEmbedding);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// This file is just an alias that points to the current learnjs version\n// at this branch, so demos can import the library as '../learnjs'.\nexport * from '../src/index';\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// tslint:disable-next-line:no-unused-variable\nimport {Array3D} from '../src/math/ndarray';\n\nimport {PolymerElement, PolymerHTMLElement} from './polymer-spec';\n\n// tslint:disable-next-line\nexport let NDArrayImageVisualizerPolymer =\n    PolymerElement({is: 'ndarray-image-visualizer', properties: {}});\n\nexport class NDArrayImageVisualizer extends NDArrayImageVisualizerPolymer {\n  private canvas: HTMLCanvasElement;\n  private canvasContext: CanvasRenderingContext2D;\n  private imageData: ImageData;\n\n  ready() {\n    this.canvas = this.querySelector('#canvas') as HTMLCanvasElement;\n    this.canvas.width = 0;\n    this.canvas.height = 0;\n    this.canvasContext =\n        this.canvas.getContext('2d') as CanvasRenderingContext2D;\n    this.canvas.style.display = 'none';\n  }\n\n  setShape(shape: number[]) {\n    this.canvas.width = shape[1];\n    this.canvas.height = shape[0];\n  }\n\n  setSize(width: number, height: number) {\n    this.canvas.style.width = width + 'px';\n    this.canvas.style.height = height + 'px';\n  }\n\n  saveImageDataFromNDArray(ndarray: Array3D) {\n    this.imageData = this.canvasContext.createImageData(\n        this.canvas.width, this.canvas.height);\n    if (ndarray.shape[2] === 1) {\n      this.drawGrayscaleImageData(ndarray);\n    } else if (ndarray.shape[2] === 3) {\n      this.drawRGBImageData(ndarray);\n    }\n  }\n\n  drawRGBImageData(ndarray: Array3D) {\n    let pixelOffset = 0;\n    for (let i = 0; i < ndarray.shape[0]; i++) {\n      for (let j = 0; j < ndarray.shape[1]; j++) {\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 0);\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 1);\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 2);\n        this.imageData.data[pixelOffset++] = 255;\n      }\n    }\n  }\n\n  drawGrayscaleImageData(ndarray: Array3D) {\n    let pixelOffset = 0;\n    for (let i = 0; i < ndarray.shape[0]; i++) {\n      for (let j = 0; j < ndarray.shape[1]; j++) {\n        const value = ndarray.get(i, j, 0);\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = 255;\n      }\n    }\n  }\n\n  draw() {\n    this.canvas.style.display = '';\n    this.canvasContext.putImageData(this.imageData, 0, 0);\n  }\n}\ndocument.registerElement(\n    NDArrayImageVisualizer.prototype.is, NDArrayImageVisualizer);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * @fileoverview\n *\n * Defines an interface for creating Polymer elements in Typescript with the\n * correct typings. A Polymer element should be defined like this:\n *\n * ```\n * let MyElementPolymer = PolymerElement({\n *   is: 'my-polymer-element',\n *   properties: {\n *     foo: string,\n *     bar: Array\n *   }\n * });\n *\n * class MyElement extends MyElementPolymer {\n *   foo: string;\n *   bar: number[];\n *\n *   ready() {\n *     console.log('MyElement initialized!');\n *   }\n * }\n *\n * document.registerElement(MyElement.prototype.is, MyElement);\n * ```\n */\n\nexport type Spec = {\n  is: string; properties: {\n    [key: string]: (Function|{\n      // tslint:disable-next-line:no-any\n      type: Function, value?: any;\n      reflectToAttribute?: boolean;\n      readonly?: boolean;\n      notify?: boolean;\n      computed?: string;\n      observer?: string;\n    })\n  };\n  observers?: string[];\n};\n\nexport function PolymerElement(spec: Spec) {\n  // tslint:disable-next-line:no-any\n  return Polymer.Class(spec as any) as {new (): PolymerHTMLElement};\n}\n\nexport interface PolymerHTMLElement extends HTMLElement, polymer.Base {}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * @hidden\n */\nexport interface CheckpointVariable {\n  filename: string;\n  shape: number[];\n}\n\n/**\n * @hidden\n */\nexport type CheckpointManifest = {\n  [varName: string]: CheckpointVariable\n};\n\nconst MANIFEST_FILE = 'manifest.json';\n\nexport class CheckpointLoader {\n  private checkpointManifest: CheckpointManifest;\n  private variables: {[varName: string]: NDArray};\n\n  constructor(private urlPath: string) {\n    if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') {\n      this.urlPath += '/';\n    }\n  }\n\n  private loadManifest(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n      xhr.open('GET', this.urlPath + MANIFEST_FILE);\n\n      xhr.onload = () => {\n        this.checkpointManifest = JSON.parse(xhr.responseText);\n        resolve();\n      };\n      xhr.onerror = (error) => {\n        throw new Error(\n            `${MANIFEST_FILE} not found at ${this.urlPath}. ` + error);\n      };\n      xhr.send();\n    });\n  }\n\n  getCheckpointManifest(): Promise<CheckpointManifest> {\n    if (this.checkpointManifest == null) {\n      return new Promise<CheckpointManifest>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          resolve(this.checkpointManifest);\n        });\n      });\n    }\n    return new Promise<CheckpointManifest>((resolve, reject) => {\n      resolve(this.checkpointManifest);\n    });\n  }\n\n  getAllVariables(): Promise<{[varName: string]: NDArray}> {\n    if (this.variables != null) {\n      return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n        resolve(this.variables);\n      });\n    }\n\n    return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n      this.getCheckpointManifest().then(\n          (checkpointDefinition: CheckpointManifest) => {\n            const variableNames = Object.keys(this.checkpointManifest);\n\n            const variablePromises: Array<Promise<NDArray>> = [];\n            for (let i = 0; i < variableNames.length; i++) {\n              variablePromises.push(this.getVariable(variableNames[i]));\n            }\n\n            Promise.all(variablePromises).then(variables => {\n              this.variables = {};\n              for (let i = 0; i < variables.length; i++) {\n                this.variables[variableNames[i]] = variables[i];\n              }\n              resolve(this.variables);\n            });\n          });\n    });\n  }\n\n  getVariable(varName: string): Promise<NDArray> {\n    if (!(varName in this.checkpointManifest)) {\n      throw new Error('Cannot load non-existant variable ' + varName);\n    }\n\n    const variableRequestPromiseMethod =\n        (resolve: (ndarray: NDArray) => void, reject: () => void) => {\n          const xhr = new XMLHttpRequest();\n          xhr.responseType = 'arraybuffer';\n          const fname = this.checkpointManifest[varName].filename;\n          xhr.open('GET', this.urlPath + fname);\n\n          xhr.onload = () => {\n            const values = new Float32Array(xhr.response);\n            const ndarray =\n                NDArray.make(this.checkpointManifest[varName].shape, {values});\n            resolve(ndarray);\n          };\n          xhr.onerror = (error) => {\n            throw new Error(\n                'Could not fetch variable ' + varName + ': ' + error);\n          };\n          xhr.send();\n        };\n\n    if (this.checkpointManifest == null) {\n      return new Promise<NDArray>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          new Promise<NDArray>(variableRequestPromiseMethod).then(resolve);\n        });\n      });\n    }\n    return new Promise<NDArray>(variableRequestPromiseMethod);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\nconst STATS_SAMPLE_PERCENTAGE = 0.1;\n\nexport interface DataStats {\n  exampleCount: number;\n  inputMin: number;\n  inputMax: number;\n  shape: number[];\n}\n\ninterface NormalizationInfo {\n  isNormalized: boolean;\n  // Bounds of the normalization if normalized.\n  lowerBound?: number;\n  upperBound?: number;\n  // Minimum and maximum values for each dimension of the original data. These\n  // are the same size as an input example. These are computed lazily, only if\n  // normalization is requested. If the data is un-normalized, these are kept\n  // around so they don't have to be recomputed.\n  minValues: Float32Array;\n  maxValues: Float32Array;\n}\n\nexport abstract class InMemoryDataset {\n  protected dataset: NDArray[][]|null;\n\n  // Contains information necessary for reconstruction of the original data\n  // after normalization.\n  private normalizationInfo: {[dataIndex: number]: NormalizationInfo};\n\n  constructor(protected dataShapes: number[][]) {\n    this.normalizationInfo = {};\n  }\n\n  getDataShape(dataIndex: number): number[] {\n    return this.dataShapes[dataIndex];\n  }\n\n  abstract fetchData(): Promise<void>;\n\n  getData(): NDArray[][]|null {\n    return this.dataset;\n  }\n\n  getStats(): DataStats[] {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    return this.dataset.map(d => this.getStatsForData(d));\n  }\n\n  // Computes stats across a sampled portion of the data.\n  private getStatsForData(data: NDArray[]): DataStats {\n    let inputMin = Number.POSITIVE_INFINITY;\n    let inputMax = Number.NEGATIVE_INFINITY;\n\n    let exampleIndices = data.map((example, i) => i);\n    util.shuffle(exampleIndices);\n    exampleIndices =\n        exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE);\n\n    for (let i = 0; i < exampleIndices.length; i++) {\n      const inputValues = data[exampleIndices[i]].getValues();\n      for (let j = 0; j < inputValues.length; j++) {\n        inputMin = Math.min(inputMin, inputValues[j]);\n        inputMax = Math.max(inputMax, inputValues[j]);\n      }\n    }\n\n    return {\n      inputMin,\n      inputMax,\n      exampleCount: data.length,\n      shape: data[0].shape,\n    };\n  }\n\n  /**\n   * @param examples NDArrays to be normalized.\n   * @param curLowerBounds An array containing the minimum value for each\n   * dimension or a fixed minimum value.\n   * @param curUpperBounds An array containing the maximum value for each\n   * dimension or a fixed maximum value.\n   * @param newLowerBounds An array containing new minimum values for each\n   * dimension, or a fixed minumum value to normalize the data to.\n   * @param newUpperBounds An array containing new maximum values for each\n   * dimension, or a fixed maximum value to normalize the data to.\n   */\n  private normalizeExamplesToRange(\n      examples: NDArray[], curLowerBounds: Float32Array|number,\n      curUpperBounds: Float32Array|number, newLowerBounds: Float32Array|number,\n      newUpperBounds: Float32Array|number): NDArray[] {\n    const curBoundsIsPerDimension =\n        (curUpperBounds instanceof Float32Array &&\n         curLowerBounds instanceof Float32Array);\n    const newBoundsIsPerDimension =\n        (newLowerBounds instanceof Float32Array &&\n         newUpperBounds instanceof Float32Array);\n\n    const inputSize = util.sizeFromShape(examples[0].shape);\n    const newExamples: NDArray[] = [];\n\n    examples.forEach(example => {\n      const inputValues = example.getValues();\n      const normalizedValues = new Float32Array(inputSize);\n      for (let j = 0; j < inputSize; j++) {\n        const curLowerBound = curBoundsIsPerDimension ?\n            (curLowerBounds as Float32Array)[j] :\n            curLowerBounds as number;\n        const curUpperBound = curBoundsIsPerDimension ?\n            (curUpperBounds as Float32Array)[j] :\n            curUpperBounds as number;\n        const curRange = curUpperBound - curLowerBound;\n\n        const newLowerBound = newBoundsIsPerDimension ?\n            (newLowerBounds as Float32Array)[j] :\n            newLowerBounds as number;\n        const newUpperBound = newBoundsIsPerDimension ?\n            (newUpperBounds as Float32Array)[j] :\n            newUpperBounds as number;\n        const newRange = newUpperBound - newLowerBound;\n\n        if (curRange === 0) {\n          normalizedValues[j] = newLowerBound;\n        } else {\n          normalizedValues[j] = newLowerBound +\n              newRange * (inputValues[j] - curLowerBound) / curRange;\n        }\n      }\n      newExamples.push(NDArray.make(example.shape, {values: normalizedValues}));\n    });\n    return newExamples;\n  }\n\n  private computeBounds(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    const size = util.sizeFromShape(this.dataset[dataIndex][0].shape);\n\n    // Compute min and max values for every dimension.\n    this.normalizationInfo[dataIndex] = {\n      isNormalized: false,\n      minValues: new Float32Array(size),\n      maxValues: new Float32Array(size)\n    };\n\n    for (let i = 0; i < size; i++) {\n      this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY;\n      this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY;\n    }\n\n    this.dataset[dataIndex].forEach(example => {\n      const inputValues = example.getValues();\n      for (let k = 0; k < size; k++) {\n        this.normalizationInfo[dataIndex].minValues[k] = Math.min(\n            this.normalizationInfo[dataIndex].minValues[k], inputValues[k]);\n        this.normalizationInfo[dataIndex].maxValues[k] = Math.max(\n            this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]);\n      }\n    });\n  }\n\n  normalizeWithinBounds(\n      dataIndex: number, lowerBound: number, upperBound: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n    if (dataIndex >= this.dataset.length) {\n      throw new Error('dataIndex out of bounds.');\n    }\n\n    if (this.normalizationInfo[dataIndex] == null) {\n      this.computeBounds(dataIndex);\n    }\n\n    // curLower/UpperBounds of the current data set can either be fixed numbers\n    // if the data has already been normalized, or curLower/Upper for each\n    // dimension if it hasn't been normalized yet.\n    let curLowerBounds: Float32Array|number;\n    let curUpperBounds: Float32Array|number;\n\n    if (this.normalizationInfo[dataIndex].isNormalized) {\n      curLowerBounds = this.normalizationInfo[dataIndex].lowerBound!;\n      curUpperBounds = this.normalizationInfo[dataIndex].upperBound!;\n    } else {\n      curLowerBounds = this.normalizationInfo[dataIndex].minValues;\n      curUpperBounds = this.normalizationInfo[dataIndex].maxValues;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound,\n        upperBound);\n    this.normalizationInfo[dataIndex].isNormalized = true;\n    this.normalizationInfo[dataIndex].lowerBound = lowerBound;\n    this.normalizationInfo[dataIndex].upperBound = upperBound;\n  }\n\n  private isNormalized(dataIndex: number): boolean {\n    return this.normalizationInfo != null &&\n        this.normalizationInfo[dataIndex].isNormalized;\n  }\n\n  removeNormalization(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Training or test data is null.');\n    }\n\n    if (!this.isNormalized(dataIndex)) {\n      return;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n    this.normalizationInfo[dataIndex].isNormalized = false;\n  }\n\n  unnormalizeExamples(examples: NDArray[], dataIndex: number): NDArray[] {\n    if (!this.isNormalized(dataIndex)) {\n      return examples;\n    }\n\n    return this.normalizeExamplesToRange(\n        examples, this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n  }\n\n  dispose() {\n    if (this.dataset == null) {\n      return;\n    }\n\n    for (let i = 0; i < this.dataset.length; i++) {\n      for (let j = 0; j < this.dataset[i].length; j++) {\n        this.dataset[i][j].dispose();\n      }\n    }\n    this.dataset = [];\n  }\n}\n\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GraphLayers} from './graph_layers';\nimport * as concat3d_util from './math/concat3d_util';\nimport * as conv_util from './math/conv_util';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * Graph is the primary container structure for learn.js operations. Graph\n * holds the topology of operation nodes and the connectivity between them.\n */\nexport class Graph {\n  layers: GraphLayers;\n\n  constructor() {\n    this.layers = new GraphLayers(this);\n  }\n\n  /**\n   * Creates a named variable. Variables are tensors that maintain state across\n   * session calls and whose values are adjusted during backpropagation\n   * training.\n   * @param name The name of this variable.\n   * @param data The NDArray to associate with this variable tensor.\n   * @return The tensor representing the variable.\n   */\n  variable(name: string, data: NDArray): Tensor {\n    return this.addNodeAndReturnOutput(new VariableNode(this, name, data));\n  }\n\n  /**\n   * Inserts a placeholder for a tensor that will be always fed. Placeholders\n   * are input tensors whose values are provided by the client via feed\n   * dictionaries. Placeholders are not updated as part of training; they are\n   * only used as immutable input.\n   * @param name The name of this placeholder.\n   * @param shape The shape of the placeholder tensor.\n   * @return The tensor representing the placeholder.\n   */\n  placeholder(name: string, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape));\n  }\n\n  /**\n   * Constant value that persists across session calls.\n   * @param value The value to return.\n   * @return A node outputing the constant value.\n   */\n  constant(value: ArrayData): Tensor {\n    let finalValue: NDArray;\n    if (typeof value === 'number') {\n      finalValue = Scalar.new(value);\n    } else if (value instanceof NDArray) {\n      finalValue = value;\n    } else if (value instanceof Array) {\n      const vals = new Float32Array(util.flatten(value));\n      finalValue = NDArray.make(util.inferShape(value), {values: vals});\n    } else {\n      throw new Error('unimplemented constant type.');\n    }\n    return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue));\n  }\n\n  /**\n   * Reshape the input tensor.\n   * @param x The input tensor to be reshaped.\n   * @param shape The shape of the output tensor.\n   * @return The tensor representing the reshape operation.\n   */\n  reshape(x: Tensor, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(\n        new ReshapeNode(this, 'Reshape', x, shape));\n  }\n\n  /**\n   * Computes a fused linear combination of two tensors.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor. Same shape as t1.\n   * @param c1 Coefficient of t1. Must be size 1.\n   * @param c2 Coefficient of t2. Must be size 1.\n   * @return The tensor representing c1*t1+c2*t2.\n   */\n  fusedLinearCombination(x1: Tensor, x2: Tensor, c1: Tensor, c2: Tensor):\n      Tensor {\n    return this.addNodeAndReturnOutput(\n        new FusedLinearCombinationNode(this, x1, x2, c1, c2));\n  }\n\n\n  /**\n   * Adds two tensors (elementwise). Broadcasts if one of the tensors is scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1+t2.\n   */\n  add(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new AddNode(this, x1, x2));\n  }\n\n  /**\n   * Subtracts two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1-t2.\n   */\n  subtract(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2));\n  }\n\n  /**\n   * Multiply two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1*t2.\n   */\n  multiply(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2));\n  }\n\n  /**\n   * Divide two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1 / t2.\n   */\n  divide(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2));\n  }\n\n  /**\n   * Computes the sum of elements in the tensor.\n   * @param x The input tensor.\n   */\n  reduceSum(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReduceSumNode(this, x));\n  }\n\n  /**\n   * Concats two 3D tensors along a given axis.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing concat of two tensors along axis.\n   */\n  concat3d(x1: Tensor, x2: Tensor, axis: number): Tensor {\n    return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis));\n  }\n\n  /**\n   * Computes the dot product between two matrices.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing the dot product of x1 and x2.\n   */\n  matmul(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2));\n  }\n\n  /**\n   * Computes a 2D convolution.\n   * @param x The input tensor to the convolution operation.\n   * @param w The weight tensor used by the convolution operation.\n   * @param b The bias tensor used by the convolution operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param outputDepth The output depth of the convolution operation.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the convolution operation.\n   */\n  conv2d(\n      x: Tensor, w: Tensor, b: Tensor, fieldSize: number, outputDepth: number,\n      stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(new Convolution2DNode(\n        this, x, w, b, fieldSize, outputDepth, stride, zeroPad));\n  }\n\n  /**\n   * Computes a 2D max pool of x.\n   * @param x The input tensor to the max pool operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the max pool operation.\n   */\n  maxPool(x: Tensor, fieldSize: number, stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(\n        new MaxPoolNode(this, x, fieldSize, stride, zeroPad));\n  }\n\n  /**\n   * Computes exponential of x element-wise.\n   * @param x The input tensor to the exp.\n   * @return The tensor representing the e ^ x operation.\n   */\n  exp(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ExpNode(this, x));\n  }\n\n  /**\n   * Computes log of x element-wise.\n   * @param x The input tensor to the log.\n   * @return The tensor representing the ln(x) operation.\n   */\n  log(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new LogNode(this, x));\n  }\n\n  /**\n   * Computes ReLU of x element-wise.\n   * @param x The input tensor to the ReLU.\n   * @return The tensor representing the ReLU operation.\n   */\n  relu(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReLUNode(this, x));\n  }\n\n  /**\n   * Computes TanH of x element-wise.\n   * @param x The input tensor to the TanH.\n   * @return The tensor representing the TanH operation.\n   */\n  tanh(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new TanHNode(this, x));\n  }\n\n  /**\n   * Computes Sigmoid of x element-wise.\n   * @param x The input tensor to the sigmoid.\n   * @return The tensor representing the sigmoid operation.\n   */\n  sigmoid(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SigmoidNode(this, x));\n  }\n\n  /**\n   * Computes square of x element-wise.\n   * @param x The input tensor to the square.\n   */\n  square(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SquareNode(this, x));\n  }\n\n  /**\n   * Computes softmax probabilities from logits.\n   *\n   * @param x The input logits.\n   * @return The softmax probabilities.\n   */\n  softmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SoftmaxNode(this, x));\n  }\n\n  /**\n   * Creates a softmax cross-entropy cost operation in the graph.\n   * @param x The input tensor to classify.\n   * @return The tensor representing the softmax cross-entropy cost operation.\n   */\n  softmaxCrossEntropyCost(x: Tensor, target: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(\n        new SoftmaxCrossEntropyCostNode(this, x, target));\n  }\n\n  /**\n   * Creates a mean-squared cost operation in the graph.\n   * @param label The label tensor.\n   * @param prediction The prediction tensor.\n   * @return The tensor representing the mean-squared cost operation.\n   */\n  meanSquaredCost(label: Tensor, prediction: Tensor) {\n    return this.addNodeAndReturnOutput(\n        new MeanSquaredCostNode(this, label, prediction));\n  }\n\n  /**\n   * Returns the flattened index of the maximum entry in the tensor.\n   * @param x The tensor with the value.\n   * @return A Scalar tensor with the index of the maximum entry.\n   */\n  argmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxNode(this, x));\n  }\n\n  /**\n   * Creates an argmax equals operation in the graph.\n   * @param x1 First input tensor to check against.\n   * @param x2 Second input tensor to check against.\n   * @return The tensor representing the argmax equals operation.\n   */\n  argmaxEquals(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2));\n  }\n\n  private addNodeAndReturnOutput(node: Node): Tensor {\n    this.nodes.push(node);\n    node.validate();\n    return node.output;\n  }\n\n  getNodes(): Node[] {\n    return this.nodes;\n  }\n\n  private nodes: Node[] = [];\n}\n\n/**\n * Tensor represents the output of an operation node in the graph.\n * Tensors have no data associated with them, but maintain a shape array\n * to determine operation compatibility. All graph methods that create graph\n * operations return Tensor objects, which can be thought of as 'handles' to\n * operations.\n */\nexport class Tensor {\n  node: Node;\n  id: number;\n  /**\n   * @param shape The shape of this tensor, in dimension sizes.\n   */\n  constructor(public shape: number[]) {\n    this.id = Tensor.nextID++;\n  }\n  private static nextID = 0;\n}\n\n/**\n * Node is the concrete base class for all operations in the graph.\n * Users generally don't need to interact directly with Node instances, but they\n * are provided for informational and introspection purposes.\n *\n * @hidden\n */\nexport abstract class Node {\n  /**\n   * @param graph The graph containing this node\n   * @param name The name of this node\n   * @param inputs A dictionary of named Tensors that comprise this node's\n   * inputs.\n   * @param output This node's output Tensor\n   */\n  constructor(\n      public graph: Graph, public name: string,\n      public inputs: {[name: string]: Tensor}, public output: Tensor) {\n    this.id = Node.nextID++;\n    output.node = this;\n  }\n  abstract validate(): void;\n  id: number;\n  private static nextID = 0;\n}\n\n/**\n * VariableNode represents a variable, a user-provided NDArray that's\n * adjusted during backpropagation training.\n *\n * @hidden\n */\nexport class VariableNode extends Node {\n  constructor(graph: Graph, name: string, public data: NDArray) {\n    super(graph, name, {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding variable op: Data for variable \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * PlaceholderNode represents a placeholder, a user-provided NDArray\n * that's used as immutable input during inference and training.\n *\n * @hidden\n */\nexport class PlaceholderNode extends Node {\n  constructor(graph: Graph, name: string, shape: number[]) {\n    super(graph, name, {}, new Tensor(shape));\n  }\n  validate() {}\n}\n\n/**\n * ConstantNode represents a constant value in the graph.\n *\n * @hidden\n */\nexport class ConstantNode extends Node {\n  constructor(graph: Graph, public data: NDArray) {\n    super(graph, 'Constant', {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding constant: data for placeholder \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * ReshapeNode represents a reshape operation in the graph.\n *\n * @hidden\n */\nexport class ReshapeNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, public name: string, private x: Tensor,\n      private shape: number[]) {\n    super(graph, name, {x}, new Tensor(shape));\n  }\n  validate() {\n    const xSize = util.sizeFromShape(this.x.shape);\n    const shapeSize = util.sizeFromShape(this.shape);\n    util.assert(\n        xSize === shapeSize,\n        'Error making reshape operation: input Tensor to reshape \\'' +\n            this.name + '\\' of shape (' + this.x.shape +\n            ') does not match size of requested shape ' + this.shape + '.');\n  }\n}\n\n/**\n * LinearCombinationNode represents a linear combination of two tensors.\n * @hidden\n */\nexport class FusedLinearCombinationNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n  static readonly C1 = 'c1';\n  static readonly C2 = 'c2';\n  constructor(\n      graph: Graph, private t1: Tensor, private t2: Tensor, private c1: Tensor,\n      private c2: Tensor) {\n    super(graph, 'Linear Combination', {t1, t2, c1, c2}, new Tensor(t1.shape));\n  }\n\n  validate() {\n    util.assertShapesMatch(this.t1.shape, this.t2.shape);\n    if (!util.isScalarShape(this.c1.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c1 is not a scalar, got ' +\n          'shape: ' + this.c1.shape);\n    }\n    if (!util.isScalarShape(this.c2.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c2 is not a scalar, got ' +\n          'shape: ' + this.c2.shape);\n    }\n  }\n}\n\n/**\n * @hidden\n */\nexport class AddNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Add', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding add operation op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SubtractNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Subtract', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding subtract op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class MultiplyNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Multiply', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding multiply op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class DivideNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Divide', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding divide op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReduceSumNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReduceSum', {x}, new Tensor([]));\n  }\n\n  validate() {}\n}\n\n/**\n * Concat3DNode represents a 3D concatenation of two tensors along an axis.\n * @hidden\n */\nexport class Concat3DNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  static readonly AXIS = 'axis';\n  constructor(\n      graph: Graph, private x1: Tensor, private x2: Tensor,\n      public axis: number) {\n    super(\n        graph, 'Concat3D', {x1, x2},\n        new Tensor(concat3d_util.computeConcat3DOutputShape(\n            x1.shape, x2.shape, axis)));\n  }\n  validate() {\n    concat3d_util.assertConcat3DShapesMatch(\n        this.x1.shape, this.x2.shape, this.axis);\n  }\n}\n\nfunction getMatMulOutputShape(x1Shape: number[], x2Shape: number[]): number[] {\n  if (x1Shape.length === 1 && x2Shape.length === 1) {\n    return [1];\n  } else if (x1Shape.length === 1 && x2Shape.length === 2) {\n    return [x2Shape[1]];\n  } else if (x1Shape.length === 2 && x2Shape.length === 1) {\n    return [x1Shape[0]];\n  }\n  return [x1Shape[0], x2Shape[1]];\n}\n\n/**\n * MatMulNode represents a fully connected layer in the graph.\n * @hidden\n */\nexport class MatMulNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(\n        graph, 'MatMul', {x1, x2},\n        new Tensor(getMatMulOutputShape(x1.shape, x2.shape)));\n  }\n\n  validate() {\n    if (this.x1.shape.length === 2 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: inner shapes of matrices with shapes ' +\n              this.x1.shape + ' and ' + this.x2.shape + ' must match.');\n    } else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: second dimension of matrix with shape ' +\n              this.x1.shape + ' must match size of vector with shape ' +\n              this.x2.shape + '.');\n    } else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[0] === this.x2.shape[0],\n          'Error adding matmul op: size of vector with shape ' + this.x1.shape +\n              ' must match first dimension of matrix with ' +\n              'shape ' + this.x2.shape + '.');\n    } else {\n      throw new Error(\n          'Error adding matmul op: inputs must be vectors or matrices.');\n    }\n  }\n}\n\n/**\n * Convolution2DNode represents a 2d convolution operation in the graph.\n * @hidden\n */\nexport class Convolution2DNode extends Node {\n  static readonly X = 'x';\n  static readonly W = 'w';\n  static readonly B = 'b';\n  constructor(\n      graph: Graph, private x: Tensor, private w: Tensor, private b: Tensor,\n      public fieldSize: number, public outputDepth: number, public stride = 1,\n      public zeroPad?: number) {\n    super(\n        graph, 'Convolution 2D', {x, w, b},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, outputDepth, stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding conv2d op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n    util.assert(\n        this.w.shape.length === 4,\n        'Error adding conv2d op: weights must be of rank 4, but got shape: ' +\n            this.w.shape + '.');\n    util.assert(\n        this.b.shape.length === 1,\n        'Error adding conv2d op: biases must be of rank 1, but got shape: ' +\n            this.b.shape + '.');\n\n    util.assert(\n        this.x.shape[2] === this.w.shape[2],\n        'Error adding conv2d op: depth of input (' + this.x.shape[2] +\n            ') must match input depth for weights (' + this.w.shape[2] + ').');\n  }\n}\n\n/**\n * MaxPoolNode represents a 2d max pool operation in the graph.\n * @hidden\n */\nexport class MaxPoolNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, private x: Tensor, public fieldSize: number,\n      public stride = 1, public zeroPad?: number) {\n    super(\n        graph, 'Max pool', {x},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, x.shape[2], stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding maxPool op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n  }\n}\n\n/**\n * ReLUNode represents a ReLU operation in the graph.\n * @hidden\n */\nexport class ReLUNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReLU', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * ExpNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class ExpNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Exp', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * LogNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class LogNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Log', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * TanHNode represents a tanh operation in the graph.\n * @hidden\n */\nexport class TanHNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'TanH', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SigmoidNode represents a sigmoid operation in the graph.\n * @hidden\n */\nexport class SigmoidNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Sigmoid', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * Square node represents an element-wise square operation in the graph.\n * @hidden\n */\nexport class SquareNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Square', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SoftmaxCrossEntropyCostNode represents a softmax cross-entropy cost operation\n * in the graph.\n * @hidden\n */\nexport class SoftmaxCrossEntropyCostNode extends Node {\n  static readonly X = 'x';\n  static readonly TARGET = 'target';\n  constructor(graph: Graph, private x: Tensor, private target: Tensor) {\n    super(graph, 'SoftmaxCrossEntropyCost', {x, target}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x.shape, this.target.shape),\n        'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape +\n            ') must match target shape (' + this.target.shape + ').');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SoftmaxNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, private x: Tensor) {\n    super(graph, 'Softmax', {x}, new Tensor(x.shape));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 1,\n        'The input to a softmax must be a 1-D tensor');\n    util.assert(\n        this.x.shape[0] >= 2,\n        'The input to a softmax must have at least 2 values');\n  }\n}\n\n/**\n * MeanSquaredCostNode represents a mean squared cost operation\n * in the graph.\n *\n * @hidden\n */\nexport class MeanSquaredCostNode extends Node {\n  static readonly LABEL = 'label';\n  static readonly PREDICTION = 'prediction';\n  constructor(graph: Graph, private label: Tensor, private prediction: Tensor) {\n    super(graph, 'Mean Squared Cost', {label, prediction}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.label.shape, this.prediction.shape),\n        'Error adding meanSquaredCost op: label shape (' + this.label.shape +\n            ') must match prediction shape (' + this.prediction.shape + ').');\n  }\n}\n\n/**\n * ArgMaxNode represents an argmax operation in the graph.\n * @hidden\n */\nexport class ArgMaxNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, public x: Tensor) {\n    super(graph, 'ArgMax', {x}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.x.shape) > 0,\n        'Error adding argmax op: input tensor must have at least one entry.');\n  }\n}\n\n/**\n * ArgMaxEqualsNode represents a argmax equals operation in the graph.\n * @hidden\n */\nexport class ArgMaxEqualsNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(graph, 'ArgMaxEquals', {x1, x2}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x1.shape, this.x2.shape),\n        'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape +\n            ') must match x2 shape (' + this.x2.shape + ').');\n  }\n}\n\n/**\n * Split nodes are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n * @hidden\n */\nexport class SplitNode extends Node {\n  static readonly X = 'x';\n\n  outputs: Tensor[] = [];\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'SplitNode', {x}, new Tensor(x.shape));\n  }\n\n  /**\n   * Registers a new consumer of this split node, i.e. a new node that uses the\n   * node's output tensor.\n   */\n  getNewOutputTensor(): Tensor {\n    const output = new Tensor(this.inputs[SplitNode.X].shape);\n    output.node = this;\n    this.outputs.push(output);\n    return output;\n  }\n  validate() {}\n}\n\n/**\n * @hidden\n */\nexport type ArrayData =\n    NDArray|number|number[]|number[][]|number[][][]|number[][][][];\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Tensor} from './graph';\nimport {Initializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nimport {NDArray} from './math/ndarray';\n\n/**\n * A layers sugar class around the graph that initializes variables\n * automatically for layers.\n */\nexport class GraphLayers {\n  constructor(private g: Graph) {}\n\n  dense(\n      name: string, x: Tensor, units: number,\n      activation: ((x: Tensor) => Tensor)|null = null, useBias = true,\n      kernelInitializer: Initializer = new VarianceScalingInitializer(),\n      biasInitializer: Initializer = new ZerosInitializer()) {\n    const weights = this.g.variable(\n        name + '-weights',\n        kernelInitializer.initialize([x.shape[0], units], x.shape[0], units));\n\n    let out = this.g.matmul(x, weights);\n\n    if (useBias) {\n      const bias = this.g.variable(\n          name + '-bias',\n          biasInitializer.initialize([units], x.shape[0], units));\n      out = this.g.add(out, bias);\n    }\n\n    if (activation != null) {\n      out = activation(out);\n    }\n\n    return out;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as dataset from './dataset';\nimport {Graph, Tensor} from './graph';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArrayMathCPU} from './math/math_cpu';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {CostReduction, FeedEntry, Session} from './session';\n\nconst DEFAULT_EVAL_INTERVAL_MS = 1500;\nconst DEFAULT_COST_INTERVAL_MS = 500;\nconst DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000;\n\nexport interface GraphRunnerEventObserver {\n  batchesTrainedCallback?: (totalBatchesTrained: number) => void;\n  avgCostCallback?: (avgCost: Scalar) => void;\n  metricCallback?: (metric: NDArray) => void;\n  inferenceExamplesCallback?:\n      (feeds: FeedEntry[][], inferenceValues: NDArray[]) => void;\n  inferenceExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  trainExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  totalTimeCallback?: (totalTimeSec: number) => void;\n  doneTrainingCallback?: () => void;\n}\n\nexport enum MetricReduction {\n  SUM,\n  MEAN\n}\n\n/**\n * A class that drives the training of a graph model given a dataset. It allows\n * the user to provide a set of callbacks for measurements like cost, accuracy,\n * and speed of training.\n */\nexport class GraphRunner {\n  private costTensor: Tensor;\n  private trainFeedEntries: FeedEntry[];\n  private batchSize: number;\n  private optimizer: Optimizer;\n  private currentTrainLoopNumBatches: number|undefined;\n  private costIntervalMs: number;\n\n  private metricTensor: Tensor|undefined;\n  private metricFeedEntries: FeedEntry[]|undefined;\n  private metricBatchSize: number|undefined;\n  private metricReduction: MetricReduction;\n  private metricIntervalMs: number;\n\n  private inferenceTensor: Tensor;\n  private inferenceFeedEntries: FeedEntry[]|undefined;\n  private inferenceExampleIntervalMs: number;\n  private inferenceExampleCount: number;\n\n  // Runtime information.\n  private isTraining: boolean;\n  private totalBatchesTrained: number;\n  private batchesTrainedThisRun: number;\n  private lastComputedMetric: NDArray;\n\n  private isInferring: boolean;\n  private currentInferenceLoopNumPasses: number|undefined;\n  private inferencePassesThisRun: number;\n\n  private trainStartTimestamp: number;\n  private lastCostTimestamp = 0;\n  private lastEvalTimestamp = 0;\n\n  private lastStopTimestamp: number|null;\n  private totalIdleTimeMs = 0;\n\n  private zeroScalar: Scalar;\n  private metricBatchSizeScalar: Scalar;\n\n  constructor(\n      private math: NDArrayMath, private session: Session,\n      private eventObserver: GraphRunnerEventObserver) {\n    this.resetStatistics();\n    this.zeroScalar = Scalar.new(0);\n  }\n\n  resetStatistics() {\n    this.totalBatchesTrained = 0;\n    this.totalIdleTimeMs = 0;\n    this.lastStopTimestamp = null;\n  }\n\n  /**\n   * Start the training loop with an optional number of batches to train for.\n   * Optionally takes a metric tensor and feed entries to compute periodically.\n   * This can be used for computing accuracy, or a similar metric.\n   */\n  train(\n      costTensor: Tensor, trainFeedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, numBatches?: number, metricTensor?: Tensor,\n      metricFeedEntries?: FeedEntry[], metricBatchSize?: number,\n      metricReduction = MetricReduction.MEAN,\n      evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS,\n      costIntervalMs = DEFAULT_COST_INTERVAL_MS) {\n    this.costTensor = costTensor;\n    this.trainFeedEntries = trainFeedEntries;\n    this.metricTensor = metricTensor;\n    this.metricFeedEntries = metricFeedEntries;\n    if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) {\n      if (this.metricBatchSizeScalar != null) {\n        this.metricBatchSizeScalar.dispose();\n      }\n      this.metricBatchSizeScalar = Scalar.new(metricBatchSize);\n    }\n    this.metricBatchSize = metricBatchSize;\n    this.metricReduction = metricReduction;\n    this.batchSize = batchSize;\n    this.optimizer = optimizer;\n\n    this.metricIntervalMs = evalIntervalMs;\n    this.costIntervalMs = costIntervalMs;\n    this.currentTrainLoopNumBatches = numBatches;\n\n    this.batchesTrainedThisRun = 0;\n    this.isTraining = true;\n    this.trainStartTimestamp = performance.now();\n    this.trainNetwork();\n  }\n\n  stopTraining() {\n    this.isTraining = false;\n    this.lastStopTimestamp = performance.now();\n  }\n\n  resumeTraining() {\n    this.isTraining = true;\n    if (this.lastStopTimestamp != null) {\n      this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp;\n    }\n    this.trainNetwork();\n  }\n\n  private trainNetwork() {\n    if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) {\n      this.stopTraining();\n    }\n\n    if (!this.isTraining) {\n      if (this.eventObserver.doneTrainingCallback != null) {\n        this.eventObserver.doneTrainingCallback();\n      }\n      return;\n    }\n\n    const start = performance.now();\n    const shouldComputeCost = this.eventObserver.avgCostCallback != null &&\n        (start - this.lastCostTimestamp > this.costIntervalMs);\n    if (shouldComputeCost) {\n      this.lastCostTimestamp = start;\n    }\n\n    const costReduction =\n        shouldComputeCost ? CostReduction.MEAN : CostReduction.NONE;\n\n    this.math.scope((keep) => {\n      const avgCost = this.session.train(\n          this.costTensor, this.trainFeedEntries, this.batchSize,\n          this.optimizer, costReduction);\n\n      if (shouldComputeCost) {\n        const trainTime = performance.now() - start;\n\n        this.eventObserver.avgCostCallback!(avgCost);\n\n        if (this.eventObserver.trainExamplesPerSecCallback != null) {\n          const examplesPerSec = (this.batchSize * 1000 / trainTime);\n          this.eventObserver.trainExamplesPerSecCallback(examplesPerSec);\n        }\n      }\n\n      if (this.eventObserver.metricCallback != null &&\n          this.metricFeedEntries != null &&\n          start - this.lastEvalTimestamp > this.metricIntervalMs) {\n        this.lastEvalTimestamp = start;\n\n        if (this.lastComputedMetric != null) {\n          this.lastComputedMetric.dispose();\n        }\n        this.lastComputedMetric = this.computeMetric();\n        this.eventObserver.metricCallback(this.lastComputedMetric);\n      }\n\n      if (this.eventObserver.totalTimeCallback != null) {\n        this.eventObserver.totalTimeCallback(\n            (start - this.trainStartTimestamp) / 1000);\n      }\n\n      this.batchesTrainedThisRun++;\n      this.totalBatchesTrained++;\n\n      if (this.eventObserver.batchesTrainedCallback != null) {\n        this.eventObserver.batchesTrainedCallback(this.totalBatchesTrained);\n      }\n\n    });\n    setTimeout(() => this.trainNetwork());\n  }\n\n  infer(\n      inferenceTensor: Tensor, inferenceFeedEntries: FeedEntry[],\n      inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS,\n      inferenceExampleCount = 5, numPasses?: number) {\n    if (this.eventObserver.inferenceExamplesCallback == null &&\n        this.eventObserver.inferenceExamplesPerSecCallback == null) {\n      throw new Error(\n          'Cannot start inference loop, no inference example or ' +\n          'examples/sec observer provided.');\n    }\n\n    // Make sure the feed values are providers, and not NDArrays.\n    for (let i = 0; i < inferenceFeedEntries.length; i++) {\n      const feedEntry = inferenceFeedEntries[i];\n\n      if (feedEntry.data instanceof NDArray) {\n        throw new Error(\n            'Cannot start inference on the model runner with feed entries of ' +\n            'type NDArray. Please use InputProviders.');\n      }\n    }\n\n    this.inferenceExampleIntervalMs = inferenceExampleIntervalMs;\n    this.inferenceTensor = inferenceTensor;\n    this.inferenceFeedEntries = inferenceFeedEntries;\n    this.inferenceExampleCount = inferenceExampleCount;\n    this.currentInferenceLoopNumPasses = numPasses;\n    if (!this.isInferring) {\n      this.inferencePassesThisRun = 0;\n      setTimeout(() => this.inferNetwork());\n    }\n    this.isInferring = true;\n  }\n\n  private inferNetwork() {\n    if (!this.isInferring ||\n        this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) {\n      return;\n    }\n\n    this.math.scope((keep, track) => {\n      const feeds: FeedEntry[][] = [];\n      const inferenceValues: NDArray[] = [];\n\n      const start = performance.now();\n      for (let i = 0; i < this.inferenceExampleCount; i++) {\n        // Populate a new FeedEntry[] populated with NDArrays.\n        const ndarrayFeedEntries: FeedEntry[] = [];\n        for (let j = 0; j < this.inferenceFeedEntries!.length; j++) {\n          const feedEntry = this.inferenceFeedEntries![j];\n          ndarrayFeedEntries.push({\n            tensor: feedEntry.tensor,\n            data:\n                track((feedEntry.data as InputProvider).getNextCopy(this.math))\n          });\n        }\n        feeds.push(ndarrayFeedEntries);\n\n        inferenceValues.push(\n            this.session.eval(this.inferenceTensor, ndarrayFeedEntries));\n      }\n\n      if (this.eventObserver.inferenceExamplesPerSecCallback != null) {\n        // Force a GPU download, since inference results are generally needed on\n        // the CPU and it's more fair to include blocking on the GPU to complete\n        // its work for the inference measurement.\n        inferenceValues[inferenceValues.length - 1].getValues();\n\n        const inferenceExamplesPerSecTime = performance.now() - start;\n\n        const examplesPerSec =\n            (this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime);\n        this.eventObserver.inferenceExamplesPerSecCallback!(examplesPerSec);\n      }\n\n      if (this.eventObserver.inferenceExamplesCallback != null) {\n        this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues);\n      }\n      this.inferencePassesThisRun++;\n\n    });\n    setTimeout(() => this.inferNetwork(), this.inferenceExampleIntervalMs);\n  }\n\n  stopInferring() {\n    this.isInferring = false;\n  }\n\n  isInferenceRunning(): boolean {\n    return this.isInferring;\n  }\n\n  computeMetric(): Scalar {\n    if (this.metricFeedEntries == null) {\n      throw new Error('Cannot compute metric, no metric FeedEntries provided.');\n    }\n\n    let metric = this.zeroScalar;\n\n    return this.math.scope((keep) => {\n      for (let i = 0; i < this.metricBatchSize!; i++) {\n        const metricValue =\n            this.session.eval(this.metricTensor!, this.metricFeedEntries!);\n\n        metric = this.math.add(metric, metricValue);\n      }\n\n      if (this.metricReduction === MetricReduction.MEAN) {\n        metric = this.math.divide(metric, this.metricBatchSizeScalar);\n      }\n\n      return metric;\n    });\n  }\n\n  getTotalBatchesTrained(): number {\n    return this.totalBatchesTrained;\n  }\n\n  getLastComputedMetric(): Scalar {\n    return this.lastComputedMetric;\n  }\n\n  setMath(math: NDArrayMath) {\n    this.math = math;\n  }\n\n  setSession(session: Session) {\n    this.session = session;\n  }\n\n  setInferenceTensor(inferenceTensor: Tensor) {\n    this.inferenceTensor = inferenceTensor;\n  }\n\n  setInferenceExampleCount(inferenceExampleCount: number) {\n    this.inferenceExampleCount = inferenceExampleCount;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Graph, Node, PlaceholderNode, Tensor, VariableNode} from './graph';\nimport * as priority_queue from './priority_queue';\nimport {PriorityQueue} from './priority_queue';\nimport {TensorArrayMap} from './tensor_array_map';\n\n/**\n * Given a target node in a graph, accumulate the set of all nodes that need to\n * be evaluated in order to evaluate the target graph. Traversal stops anywhere\n * a node's values are fed in externally via \"feed dicts\".\n * @param nodes The nodes to be evaluated.\n * @param terminatingNodes The set of nodes that stop traversal.\n * @return The unordered set of nodes that need to be evaluated.\n */\nexport function getUnorderedEvaluationSet(\n    nodes: Node[], terminatingNodes: Node[]): Node[] {\n  const terminatingNodeMap: {[id: number]: Node} = {};\n  const seen: {[id: number]: Node} = {};\n  const set: Node[] = [];\n  const visit: Node[] = nodes.slice();\n  terminatingNodes.forEach(node => terminatingNodeMap[node.id] = node);\n  /* Flood fill: While the 'to visit' stack is not empty, pop a node off of it.\n   * If the node has not yet been visited, add it to the set, mark it as seen,\n   * and enqueue all of its ancestor (input) nodes. */\n  while (visit.length !== 0) {\n    const cur = visit.pop()!;\n    if (seen[cur.id] == null) {\n      if (terminatingNodeMap[cur.id] == null) {\n        Object.keys(cur.inputs)\n            .map(inputName => cur.inputs[inputName])\n            .forEach(input => visit.push(input.node));\n      }\n      set.push(cur);\n      seen[cur.id] = cur;\n    }\n  }\n  return set;\n}\n\n/**\n * Given a set of nodes, compute their order such that all dependent nodes are\n * evaluated after their dependees. This is the 'inference order' for nodes in\n * the operation graph.\n * @param unorderedEvaluationSet The unordered set of nodes that need to be\n * evaluated.\n * @return The input nodes in forward evaluation order.\n */\nexport function getOrderedEvaluationSet(unorderedEvaluationSet: Node[]):\n    Node[] {\n  /* A priority queue is used, where the priority is the remaining number of\n   * unevaluated nodes whose inputs come from the element node. This guarantees\n   * that all downstream nodes will be dequeued before their ancestors. */\n  const set: Node[] = [];\n  const nodeIndices: {[id: number]: number} = {};\n  const pendingDependencies: {[id: number]: number} = {};\n\n  /* The queue priority callback looks at the number of pending dependencies of\n   * a given node. The queue index observer callback maintains the location of\n   * each node in the array, for priority updates. */\n  const nodeQueue = new PriorityQueue<Node>(\n      (a: Node, b: Node) => priority_queue.defaultCompare(\n          pendingDependencies[a.id], pendingDependencies[b.id]),\n      (node: Node, newIndex: number) => nodeIndices[node.id] = newIndex);\n\n  unorderedEvaluationSet.forEach(node => pendingDependencies[node.id] = 0);\n\n  /* For every descendent of a node (output of ancestor is input to descendant),\n   * increment the 'pending dependency count' for the ancestor. This prepares\n   * the 'pending dependency count' as a priority map. */\n  unorderedEvaluationSet.forEach(\n      node => Object.keys(node.inputs)\n                  .map(key => node.inputs[key])\n                  .forEach(input => {\n                    if (unorderedEvaluationSet.indexOf(input.node) !== -1) {\n                      pendingDependencies[input.node.id]++;\n                    }\n                  }));\n\n  unorderedEvaluationSet.forEach(node => nodeQueue.enqueue(node));\n\n  while (!nodeQueue.empty()) {\n    set.unshift(nodeQueue.dequeue());\n    /* As each node is visited, decrement the 'pending dependency count' of\n     * each ancestor, and tell the priority queue that the priority has changed.\n     */\n    Object.keys(set[0].inputs).map(key => set[0].inputs[key]).forEach(input => {\n      if (unorderedEvaluationSet.indexOf(input.node) === -1) {\n        return;\n      }\n      pendingDependencies[input.node.id]--;\n      nodeQueue.update(input.node, nodeIndices[input.node.id]);\n    });\n  }\n\n  return set;\n}\n\n/**\n * @return True iff the node is an input node.\n */\nexport function isInputNode(node: Node): boolean {\n  return Object.keys(node.inputs).length === 0;\n}\n\nexport function shouldBackProp(t: Tensor): boolean {\n  return !(t.node instanceof ConstantNode);\n}\n\nexport function isPassthroughNode(node: Node, map: TensorArrayMap): boolean {\n  const keys = Object.keys(node.inputs);\n  for (let i = 0; i < keys.length; i++) {\n    const input = node.inputs[keys[i]];\n    if (map.get(input, true) === map.get(node.output, true)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from './math/conv_util';\nimport * as gpgpu_util from './math/webgl/gpgpu_util';\nimport * as render_ndarray_gpu_util from './math/webgl/render_ndarray_gpu_util';\nimport * as webgl_util from './math/webgl/webgl_util';\nimport * as util from './util';\n\nexport {CheckpointLoader} from './checkpoint_loader';\nexport {DataStats, InMemoryDataset} from './dataset';\nexport {Graph, Tensor} from './graph';\nexport {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner';\nexport {ConstantInitializer, Initializer, NDArrayInitializer, OnesInitializer, RandomNormalInitializer, RandomTruncatedNormalInitializer, RandomUniformInitializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nexport {InCPUMemoryShuffledInputProviderBuilder, InGPUMemoryShuffledInputProviderBuilder, InputProvider} from './input_provider';\nexport {MatrixOrientation, NDArrayMath} from './math/math';\nexport {NDArrayMathCPU} from './math/math_cpu';\nexport {NDArrayMathGPU} from './math/math_gpu';\nexport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './math/ndarray';\nexport {GPGPUContext} from './math/webgl/gpgpu_context';\nexport {Optimizer} from './optimizer';\nexport {CostReduction, FeedEntry, Session} from './session';\nexport {SGDOptimizer} from './sgd_optimizer';\n// Second level exports.\nexport {conv_util, gpgpu_util, render_ndarray_gpu_util, util, webgl_util};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * Initializer interface, all initializer implement this interface.\n */\nexport interface Initializer {\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray;\n}\n\nexport class VarianceScalingInitializer implements Initializer {\n  constructor(\n      private scale = 1.0,\n      private mode: 'fan_in'|'fan_out'|'fan_avg' = 'fan_in',\n      private distribution: 'uniform'|'normal' = 'normal') {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    let n = 0;\n    if (this.mode === 'fan_in') {\n      n = inputUnits;\n    } else if (this.mode === 'fan_out') {\n      n = outputUnits;\n    } else if (this.mode === 'fan_avg') {\n      n = (inputUnits + outputUnits) / 2;\n    } else {\n      throw new Error(\n          'Unexpected mode for variance scaling initializer: ' + this.mode);\n    }\n\n    if (this.distribution === 'normal') {\n      return NDArray.randTruncatedNormal(\n          weightsShape, 0.0, Math.sqrt(this.scale / n));\n    } else if (this.distribution === 'uniform') {\n      return NDArray.randUniform(\n          weightsShape, 0.0, Math.sqrt(3 * this.scale / n));\n    } else {\n      throw new Error(\n          'Unexpected distribution for variance scaling initializer: ' +\n          this.distribution);\n    }\n  }\n}\n\nexport class ZerosInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.zeros(weightsShape);\n  }\n}\n\nexport class OnesInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(1);\n    return values;\n  }\n}\n\nexport class ConstantInitializer implements Initializer {\n  constructor(private value = 0) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(this.value);\n    return values;\n  }\n}\n\nexport class NDArrayInitializer implements Initializer {\n  constructor(private ndarray: NDArray) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return this.ndarray;\n  }\n}\n\nexport class RandomNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomTruncatedNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomUniformInitializer implements Initializer {\n  constructor(private minval = -.05, private maxval = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randUniform(weightsShape, this.minval, this.maxval);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * The interface for input providers.\n */\nexport interface InputProvider {\n  /**\n   * Get the next input as a copy. This is important because the data might\n   * get uploaded to the GPU and modify the original data.\n   * @param math NDArrayMath\n   */\n  getNextCopy(math: NDArrayMath): NDArray;\n  /**\n   * Dispose the input copy.\n   * @param math NDArrayMath\n   * @param copy The copy provided from getNextCopy\n   */\n  disposeCopy(math: NDArrayMath, copy: NDArray): void;\n}\n\n/**\n * A common interface for shuffled input provider builders. This returns\n * InputProviders that are synchronized.\n * @hidden\n */\nexport interface ShuffledInputProviderBuilder {\n  getInputProviders(): InputProvider[];\n}\n\n/**\n * @hidden\n */\nexport abstract class InMemoryShuffledInputProviderBuilder implements\n    ShuffledInputProviderBuilder {\n  protected shuffledIndices: Uint32Array;\n  protected numInputs: number;\n\n  protected idx = 0;\n  // Counter for how many times the current index has been called. Resets to 0\n  // when it reaches the number of inputs.\n  protected inputCounter = 0;\n  protected epoch = 0;\n\n  /**\n   * Constructs an `InMemoryShuffledInputProvider`. All of the inputs must be\n   * in memory.\n   * @param inputs All of the inputs, size: [number of inputs][number of\n   * examples].\n   */\n  constructor(protected inputs: NDArray[][]) {\n    this.shuffledIndices = util.createShuffledIndices(inputs[0].length);\n    this.numInputs = inputs.length;\n\n    // Make sure the number of examples in each input matches.\n    const numExamples = this.inputs[0].length;\n    for (let i = 0; i < this.numInputs; i++) {\n      util.assert(\n          this.inputs[i].length === numExamples,\n          'Number of examples must match across different inputs.');\n    }\n\n    // Make sure the shapes within inputs all match.\n    for (let i = 0; i < this.numInputs; i++) {\n      const inputShape = this.inputs[i][0].shape;\n      for (let j = 0; j < this.inputs[i].length; j++) {\n        util.assertShapesMatch(inputShape, this.inputs[i][j].shape);\n      }\n    }\n  }\n\n  protected getCurrentExampleIndex(): number {\n    const returnIdx = this.idx;\n\n    this.inputCounter++;\n    if (this.inputCounter >= this.numInputs) {\n      this.idx++;\n      this.inputCounter = 0;\n\n      if (this.idx >= this.inputs[0].length) {\n        this.idx = 0;\n        this.epoch++;\n      }\n    }\n    return returnIdx;\n  }\n\n  protected getNextInput(inputId: number): NDArray {\n    const currentExampleIndex = this.getCurrentExampleIndex();\n\n    return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]];\n  }\n\n  getEpoch() {\n    return this.epoch;\n  }\n\n  /**\n   * Returns input providers which shuffle the inputs and stay in sync.\n   */\n  getInputProviders(): InputProvider[] {\n    const inputProviders: InputProvider[] = [];\n\n    for (let i = 0; i < this.numInputs; i++) {\n      inputProviders.push(this.getInputProvider(i));\n    }\n    return inputProviders;\n  }\n\n  abstract getInputProvider(inputId: number): InputProvider;\n}\n\n/**\n * An in CPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * CPU and keeps them mutually in sync.\n */\nexport class InCPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return NDArray.like(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n\n/**\n * An in GPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * GPU and keeps them mutually in sync. This is more performant than the CPU\n * version as textures will stay in memory, however this is more GPU memory\n * intensive as it keeps textures resident in GPU memory.\n */\nexport class InGPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return math.clone(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/** A node's activation function and its derivative. */\nexport interface ActivationFunction {\n  output<T extends NDArray>(math: NDArrayMath, input: T): T;\n  der<T extends NDArray>(math: NDArrayMath, input: T, output: T): T;\n}\n\nexport class TanHFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.tanh(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      const ySquared = math.elementWiseMul(y, y);\n      // 1 - y^2.\n      return math.scalarMinusArray(Scalar.ONE, ySquared);\n    });\n  }\n}\n\nexport class ReLUFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.relu(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      return math.step(x);\n    });\n  }\n}\n\nexport class SigmoidFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.sigmoid(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // y * (1 - y) = y - y^2\n      const ySquared = math.elementWiseMul(y, y);\n      return math.sub(y, ySquared);\n    });\n  }\n}\n\nexport class SquareFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.elementWiseMul(x, x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // dy/dx = 2*x.\n      return math.scalarTimesArray(Scalar.TWO, x);\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function assertConcat3DShapesMatch(\n    x1Shape: number[], x2Shape: number[], axis: number,\n    errorMessagePrefix = '') {\n  util.assert(\n      x1Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.');\n  util.assert(\n      x2Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.');\n\n  util.assert(\n      axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.');\n\n  for (let i = 0; i < 3; i++) {\n    util.assert(\n        (i === axis) || (x1Shape[i] === x2Shape[i]),\n        errorMessagePrefix +\n            `Shape (${x1Shape}) does not match (${x2Shape}) along ` +\n            `non-concatenated axis.`);\n  }\n}\n\nexport function computeConcat3DOutputShape(\n    x1Shape: number[], x2Shape: number[],\n    axis: number): [number, number, number] {\n  util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.');\n  util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.');\n\n  const outputShape = x1Shape.slice();\n  outputShape[axis] += x2Shape[axis];\n  return outputShape as [number, number, number];\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function computeOutputShape3D(\n    inputShapeRowColDepth: [number, number, number], fieldSize: number,\n    depth: number, stride: number, zeroPad?: number): [number, number, number] {\n  if (zeroPad == null) {\n    zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride);\n  }\n  const inputRows = inputShapeRowColDepth[0];\n  const inputCols = inputShapeRowColDepth[1];\n  const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputRows),\n      `The output # of rows (${outputRows}) must be an integer. Change the ` +\n          `stride and/or zero pad parameters`);\n\n  const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputCols),\n      `The output # of columns (${outputCols}) must be an integer. Change ` +\n          `the stride and/or zero pad parameters`);\n\n  return [outputRows, outputCols, depth];\n}\n\nexport function computeDefaultPad(\n    inputShape: [number, number, number], fieldSize: number,\n    stride: number): number {\n  return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2);\n}\n\nexport function computeTexShapeFrom3D(\n    shapeRowColDepth: [number, number, number]): [number, number] {\n  return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]];\n}\n\nexport function computeWeightsShape4D(\n    inputDepth: number, outputDepth: number,\n    fSize: number): [number, number, number, number] {\n  return [fSize, fSize, inputDepth, outputDepth];\n}\n\nexport function computeWeightsTexShape(\n    inputDepth: number, outputDepth: number,\n    fieldSize: number): [number, number] {\n  return [fieldSize * fieldSize * inputDepth, outputDepth];\n}\n\nexport function computeBiasesTexShape(outputDepth: number): [number, number] {\n  return [1, outputDepth];\n}\n\nexport function computeDilatedRC(\n    rc: [number, number], origStride: number): [number, number] {\n  const rowsDilated = (rc[0] - 1) * origStride + 1;\n  const colsDilated = (rc[1] - 1) * origStride + 1;\n  return [rowsDilated, colsDilated];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function validateShapes(\n    sourceSize: [number, number], destSize: [number, number]) {\n  const srcArea = sourceSize[0] * sourceSize[1];\n  const dstArea = destSize[0] * destSize[1];\n  if (srcArea !== dstArea) {\n    const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']';\n    const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']';\n    throw new Error(\n        'copy2D shapes have different areas:\\n  sourceSize ' + srcStr +\n        ', area ' + srcArea + '\\n  destSize ' + dstStr + ', area ' + dstArea);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/**\n * An error function and its derivative.\n */\nexport interface ElementWiseCostFunction {\n  cost<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  der<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  dispose(): void;\n}\n\nexport class SquareCostFunc implements ElementWiseCostFunction {\n  private halfOne = Scalar.new(0.5);\n\n  cost(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    const diff = math.sub(x1, x2);\n    const diffSquared = math.elementWiseMul(diff, diff);\n    const result = math.scalarTimesArray(this.halfOne, diffSquared);\n\n    diff.dispose();\n    diffSquared.dispose();\n\n    return result;\n  }\n\n  der(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    return math.sub(x1, x2);\n  }\n\n  dispose() {\n    this.halfOne.dispose();\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2d_util from './copy2d_util';\n\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport type ScopeResult = NDArray[]|NDArray|void;\n\nexport abstract class NDArrayMath {\n  private ndarrayScopes: NDArray[][] = [];\n  private activeScope: NDArray[];\n\n  private ndarraysToKeep: NDArray[][] = [];\n  private activeScopeNDArraysToKeep: NDArray[] = [];\n\n  /**\n   * @param safeMode In safe mode, you must use math operations inside\n   * a math.scope() which will automatically clean up intermediate NDArrays.\n   */\n  constructor(private safeMode: boolean) {}\n\n  /**\n   * Create a new math scope. Put chained math operations inside a scope\n   * function closure so that the library automatically cleans up NDArrays\n   * from intermediate math operations. You must create a scope in safe mode\n   * to call math operations. If a result is returned from the scope, it will\n   * also be tracked, which means there must be yet another wrapping scope.\n   * @param scopeFn The function to execute with chained math operations.\n   */\n  scope<T extends ScopeResult>(\n      scopeFn:\n          (keep: <T1 extends NDArray>(ndarray: T1) => T1,\n           track: <T2 extends NDArray>(ndarray: T2) => T2) => T) {\n    this.startScope();\n\n    const keepFn = <T extends NDArray>(ndarray: T): T => this.keep(ndarray);\n    const trackFn = <T extends NDArray>(ndarray: T): T => this.track(ndarray);\n    const result = scopeFn(keepFn, trackFn);\n\n    this.endScope(result);\n\n    return result;\n  }\n\n  /**\n   * Start a scope. Use this with endScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  startScope() {\n    const newScope: NDArray[] = [];\n    this.ndarrayScopes.push(newScope);\n    this.activeScope = newScope;\n\n    const newNDArraysToKeep: NDArray[] = [];\n    this.ndarraysToKeep.push(newNDArraysToKeep);\n    this.activeScopeNDArraysToKeep = newNDArraysToKeep;\n  }\n\n  /**\n   * End a scope. Use this with startScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  endScope(result: ScopeResult) {\n    // Dispose the current scope.\n    for (let i = 0; i < this.activeScope.length; i++) {\n      const ndarray = this.activeScope[i];\n\n      if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) ||\n          (result != null && result instanceof NDArray &&\n           ndarray.getData() === (result as NDArray).getData())) {\n        continue;\n      }\n      ndarray.dispose();\n    }\n\n    // Pop the current scope.\n    this.ndarrayScopes.pop();\n    this.activeScope = this.ndarrayScopes.length === 0 ?\n        null! :\n        this.ndarrayScopes[this.ndarrayScopes.length - 1];\n\n    // Track the current result in the parent scope.\n    if (result instanceof NDArray &&\n        !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) {\n      this.track(result);\n    } else if (Array.isArray(result)) {\n      result.forEach(r => {\n        if (r instanceof NDArray &&\n            !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) {\n          this.track(r);\n        }\n      });\n    }\n\n    this.ndarraysToKeep.pop();\n    this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ?\n        null! :\n        this.ndarraysToKeep[this.ndarraysToKeep.length - 1];\n  }\n\n  private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) {\n    for (let i = 0; i < ndarrayList.length; i++) {\n      if (ndarrayList[i].getData() === ndarray.getData()) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Keeps an NDArray in the current scope from being disposed automatically.\n   * @param result The NDArray to keep from being disposed.\n   */\n  keep<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScopeNDArraysToKeep.push(result);\n    return result;\n  }\n\n  /**\n   * Tracks an NDArray in the current scope to be automatically cleaned up when\n   * the current scope ends, and returns the value.\n   * @param result The NDArray to track in the current scope.\n   */\n  track<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScope.push(result);\n    return result;\n  }\n\n  /**\n   * Computes the dot product of two matrices, A * B. These must be matrices,\n   * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct\n   * in other cases.\n   * @param a First matrix in dot product operation.\n   * @param b Second matrix in dot product operation.\n   * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will\n   * compute A^T * B.\n   * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will\n   * compute A * B^T.\n   */\n  matMul(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const innerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const innerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1];\n\n    util.assert(\n        a.rank === 2 && b.rank === 2,\n        `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` +\n            `and ${b.rank}.`);\n\n    util.assert(\n        innerShapeA === innerShapeB,\n        `Error in matMul: inner shapes (${innerShapeA}) and (` +\n            `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` +\n            `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` +\n            ` and ${MatrixOrientation[bOrientation]} must match.`);\n\n    return this.track(this.matMulInternal(a, b, aOrientation, bOrientation));\n  }\n  protected abstract matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D;\n\n  /**\n   * Computes the dot product of a vector and a matrix, v * B.\n   * @param v The vector in dot product operation.\n   * @param matrix The matrix in dot product operation.\n   */\n  vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: first input must be rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: second input must be rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[0],\n        `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `rank ${matrix.rank}.`);\n\n    return this.matMul(v.as2D(1, v.size), matrix).as1D();\n  }\n\n  /**\n   * Computes the dot product of a matrix and vector, A * v.\n   * @param matrix The matrix in dot product operation.\n   * @param v The vector in dot product operation.\n   */\n  matrixTimesVector(matrix: Array2D, v: Array1D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: second input must rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: first input must be a rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[1],\n        `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `shape ${matrix.shape}.`);\n\n    return this.matMul(matrix, v.as2D(v.size, 1)).as1D();\n  }\n\n  /**\n   * Computes the dot product of two vectors, v1 * v2.\n   * @param v1 The first vector in the dot product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  dotProduct(v1: Array1D, v2: Array1D): Scalar {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in dotProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n    util.assert(\n        v1.size === v2.size,\n        `Error in dotProduct: size of inputs (${v1.size}) and (` +\n            `${v2.size}) must match.`);\n    return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar();\n  }\n\n  /**\n   * Computes the outer product of two vectors, v1 and v2.\n   * @param v1 The first vector in the outer product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  outerProduct(v1: Array1D, v2: Array1D): Array2D {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in outerProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n\n    return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size));\n  }\n\n  ///////////////\n  // Shape ops //\n  ///////////////\n\n  /**\n   * Clones an NDArray of any shape.\n   * @param ndarray The NDArray to clone.\n   */\n  clone<T extends NDArray>(ndarray: T): T {\n    return this.track(this.cloneInternal(ndarray));\n  }\n  protected abstract cloneInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Reshapes an NDArray to a new shape. The size of the input NDArray must\n   * match the size of the requested shape.\n   * @param ndarray The input NDArray.\n   * @param newShape The new shape to reshape the NDArray to. Must be the same\n   * size as the NDArray.\n   */\n  reshape<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    util.assert(\n        ndarray.size === util.sizeFromShape(newShape),\n        `Error in reshape: old size ${ndarray.size} must match new size ` +\n            `${util.sizeFromShape(newShape)}.`);\n    return this.track(this.reshapeInternal<T1, T2>(ndarray, newShape));\n  }\n  protected abstract reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2;\n\n  /**\n   * Extracts a slice from a matrix. The operation extraces a slice from input\n   * that starts at coordinates `begin` and is of size `size`.\n   * @param input The input matrix to slice from.\n   * @param begin The 2D coordinates in the input matrix to start the slice\n   * from.\n   * @param size The sice of the 2D window to slice.\n   */\n  slice2D(input: Array2D, begin: [number, number], size: [number, number]):\n      Array2D {\n    util.assert(\n        begin[0] + size[0] <= input.shape[0] &&\n            begin[1] + size[1] <= input.shape[1],\n        `Error in slice2D: requested start position ${begin} and size ` +\n            `${size} would overflow input of shape ${input.shape}.`);\n    return this.track(this.slice2DInternal(input, begin, size));\n  }\n  protected abstract slice2DInternal(\n      input: Array2D, begin: [number, number], size: [number, number]): Array2D;\n\n  /**\n   * Copies a window from the `source` matrix starting at `sourceBegin` and is\n   * of size `sourceSize` to a window in the `dest` matrix starting at\n   * `destBegin` and is of size `destSize`/\n   * @param source The source matrix to copy from.\n   * @param sourceBegin The coordinates to start the copy from.\n   * @param sourceSize The size of the copy window.\n   * @param dest The destination matrix to copy to.\n   * @param destBegin The coordinates in `dest` to copy to.\n   * @param destSize The size of the destination window.\n   */\n  copy2D(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]) {\n    util.assert(\n        sourceBegin[0] + sourceSize[0] <= source.shape[0] &&\n            sourceBegin[1] + sourceSize[1] <= source.shape[1],\n        `Error in copy2D: requested source start position ${sourceBegin} ` +\n            `and source size ${sourceSize} would overflow source NDArray` +\n            `of shape ${source.shape}.`);\n    util.assert(\n        destBegin[0] + destSize[0] <= dest.shape[0] &&\n            destBegin[1] + destSize[1] <= dest.shape[1],\n        `Error in copy2D: requested dest start position ${destBegin} ` +\n            `and source size ${destSize} would overflow dest NDArray of` +\n            `shape ${dest.shape}.`);\n    copy2d_util.validateShapes(sourceSize, destSize);\n\n    return this.copy2DInternal(\n        source, sourceBegin, sourceSize, dest, destBegin, destSize);\n  }\n  protected abstract copy2DInternal(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]): void;\n\n  /**\n   * Concatenates two 3D ndarrays along a given axis.\n   *\n   * For example, if:\n   * A: shape(2, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *\n   * B: shape(2, 1, 3) = | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * C = concat3D(A, B, axis)\n   *\n   * if axis = 0:\n   * C: shape(4, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *                     | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * if axis = 1:\n   * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |\n   *                     | r2, g2, b2, r4, g4, b4 |\n   *\n   * if axis = 2:\n   * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |\n   *                      | r2, g2, b2, r4, g4, b4 |\n   *\n   * @param ndarray1 The first array to concat.\n   * @param ndarray2 The second array to conat.\n   * @param axis The axis to concate along.\n   */\n  concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D {\n    concat3d_util.assertConcat3DShapesMatch(\n        ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: ');\n    return this.track(this.concat3DInternal(ndarray1, ndarray2, axis));\n  }\n  protected abstract concat3DInternal(\n      ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D;\n\n  ///////////////////\n  // Reduction ops //\n  ///////////////////\n\n  /**\n   * Computes the the log(sum(e ^ x)) for each x in the input ndarray.\n   * @param ndarray The input NDArray to compute the logSumExp over.\n   */\n  logSumExp(ndarray: NDArray): Scalar {\n    return this.track(this.logSumExpInternal(ndarray));\n  }\n  protected abstract logSumExpInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the sum of all the entries in the input NDArray.\n   * @param ndarray The input NDArray to compute the sum over.\n   */\n  sum(ndarray: NDArray): Scalar {\n    return this.track(this.sumInternal(ndarray));\n  }\n  protected abstract sumInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the minimum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMin(ndarray: NDArray): Scalar {\n    return this.track(this.argMinInternal(ndarray));\n  }\n  protected abstract argMinInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the maximum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMax(ndarray: NDArray): Scalar {\n    return this.track(this.argMaxInternal(ndarray));\n  }\n  protected abstract argMaxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0.\n   * @param x1 The first input NDArray.\n   * @param x2 The second input NDArray.\n   */\n  argMaxEquals(x1: NDArray, x2: NDArray): Scalar {\n    util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: ');\n    return this.track(this.argMaxEqualsInternal(x1, x2));\n  }\n  protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar;\n\n  /**\n   * Computes the top K values and flattened indices.\n   * @param ndarray The input NDArray.\n   * @param k How many top values to compute.\n   */\n  topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} {\n    util.assert(\n        k <= ndarray.size,\n        `Error in topK: k value (${k}) must be less than size of input ` +\n            `ndarray, got shape ${ndarray.shape}.`);\n    const result = this.topKInternal(ndarray, k);\n    this.track(result.values);\n    this.track(result.indices);\n    return result;\n  }\n  protected abstract topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D};\n\n  /**\n   * Computes the minimum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  min(ndarray: NDArray): Scalar {\n    return this.track(this.minInternal(ndarray));\n  }\n  protected abstract minInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the maximum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  max(ndarray: NDArray): Scalar {\n    return this.track(this.maxInternal(ndarray));\n  }\n  protected abstract maxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the softmax normalized vector from the input vector.\n   * @param x The input vector.\n   */\n  softmax(x: Array1D): Array1D {\n    return this.scope(() => {\n      // Do it in log space for numerical stability.\n      // exp(X - logSumExp(X))\n      const lse = this.logSumExp(x);\n      const logResult = this.arrayMinusScalar(x, lse);\n      return this.exp(logResult);\n    });\n  }\n\n  //////////////////////\n  // Element-wise ops //\n  //////////////////////\n\n  /**\n   * Switches dimensions of the input NDArray.\n   * @param a The input NDArray.\n   * @param newDim The new indices that define which shapes values to switch.\n   */\n  switchDim<T extends NDArray>(a: T, newDim: number[]): T {\n    util.assert(\n        a.rank === newDim.length,\n        `Error in switchDim: length of input shape ${a.shape} ` +\n            `must match size of newDim array ${newDim}.`);\n    return this.track(this.switchDimInternal(a, newDim));\n  }\n  protected abstract switchDimInternal<T extends NDArray>(\n      a: T, newDim: number[]): T;\n\n  /**\n   * Computes a scalar plus NDArray, c + A.\n   * @param c The scalar c in c + A.\n   * @param a The NDArray A in c + A.\n   */\n  scalarPlusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarPlusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarPlusArrayInternal(c, a));\n  }\n  protected abstract scalarPlusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, c - A.\n   * @param c The scalar c in c - A.\n   * @param a The NDArray A in c - A.\n   */\n  scalarMinusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarMinusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarMinusArrayInternal(c, a));\n  }\n  protected abstract scalarMinusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, A - c.\n   * @param a The NDArray A in A - c.\n   * @param c The scalar c in A - c.\n   */\n  arrayMinusScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayMinusScalar: second argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.arrayMinusScalarInternal(a, c));\n  }\n  protected abstract arrayMinusScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes -1 * A element-wise.\n   * @param a The input array.\n   */\n  neg<T extends NDArray>(a: T): T {\n    return this.track(this.negInternal(a));\n  }\n  protected abstract negInternal<T extends NDArray>(a: T): T;\n\n  /**\n   * Adds two NDArrays element-wise, A + B. Inputs must be the same shape.\n   * @param a The first NDArray to add element-wise.\n   * @param b The second NDArray to add element-wise.\n   */\n  add<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in add: ');\n    return this.track(this.addInternal(a, b));\n  }\n  protected abstract addInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape.\n   * @param a The first NDArray to subtract element-wise.\n   * @param b The second NDArray to subtract element-wise.\n   */\n  sub<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in sub: ');\n    return this.track(this.subInternal(a, b));\n  }\n  protected abstract subInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must\n   * be the same shape.\n   * @param a The first NDArray to multiply element-wise.\n   * @param b The second NDArray to multiply element-wise.\n   */\n  elementWiseMul<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: ');\n    return this.track(this.elementWiseMulInternal(a, b));\n  }\n  protected abstract elementWiseMulInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be\n   * the same shape.\n   * @param a The first NDArray to divide element-wise.\n   * @param b The second NDArray to divide element-wise.\n   */\n  divide<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in divide: ');\n    return this.track(this.divideInternal(a, b));\n  }\n  protected abstract divideInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c /\n   * A.\n   * @param c The scalar value in c / A.\n   * @param a The NDArray value in c / A.\n   */\n  scalarDividedByArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarDividedByArray: first argument must be rank 0, but ` +\n            `got NDArray of rank ${c.rank}.`);\n    return this.track(this.scalarDividedByArrayInternal(c, a));\n  }\n  protected abstract scalarDividedByArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A /\n   * c.\n   * @param a The NDArray value in A / c.\n   * @param c The scalar value in A / c.\n   */\n  arrayDividedByScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: second argument must be rank 0, ` +\n            `but got NDArray of rank ${c.rank}.`);\n    return this.track(this.arrayDividedByScalarInternal(a, c));\n  }\n  protected abstract arrayDividedByScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes exponential of the input NDArray element-wise. y = e ^ x\n   * @param ndarray The input NDArray.\n   */\n  exp<T extends NDArray>(ndarray: T): T {\n    return this.track(this.expInternal(ndarray));\n  }\n  protected abstract expInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes natural logarithm of the input NDArray element-wise. y = ln(x)\n   * @param ndarray The input NDArray.\n   */\n  log<T extends NDArray>(ndarray: T): T {\n    return this.track(this.logInternal(ndarray));\n  }\n  protected abstract logInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes rectified linear element-wise, max(x, 0).\n   * @param ndarray The input NDArray.\n   */\n  relu<T extends NDArray>(ndarray: T): T {\n    return this.track(this.reluInternal(ndarray));\n  }\n  protected abstract reluInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)).\n   * @param ndarray The input NDArray.\n   */\n  sigmoid<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sigmoidInternal(ndarray));\n  }\n  protected abstract sigmoidInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes hyperbolic tangent of the input NDArray element-wise.\n   * @param ndarray The input NDArray.\n   */\n  tanh<T extends NDArray>(ndarray: T): T {\n    return this.track(this.tanhInternal(ndarray));\n  }\n  protected abstract tanhInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sin of the input NDArray element-wise, y = sin(x).\n   * @param ndarray The input NDArray.\n   */\n  sin<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sinInternal(ndarray));\n  }\n  protected abstract sinInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <=\n   * 0\n   * @param ndarray The input NDArray.\n   */\n  step<T extends NDArray>(ndarray: T): T {\n    return this.track(this.stepInternal(ndarray));\n  }\n  protected abstract stepInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes a scaled array add operation, c1 * A + c2 * B.\n   * @param c1 The first scalar in the scaled array add computation.\n   * @param a The first NDArray in the scaled array add computation.\n   * @param c2 The second scalar in the scaled array add computation.\n   * @param cb The second NDArray in the scaled array add computation.\n   */\n  scaledArrayAdd<T extends NDArray>(c1: Scalar, a: T, c2: Scalar, b: T): T {\n    util.assert(\n        c1.size === 1,\n        `Error in scaledArrayAdd: first argument must rank 0, but got ` +\n            ` rank ${c1.rank}.`);\n    util.assert(\n        c2.size === 1,\n        `Error in scaledArrayAdd: third argument must be rank 0, but got ` +\n            `NDArray of rank ${c2.rank}.`);\n    util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: ');\n\n    return this.track(this.scaledArrayAddInternal(c1, a, c2, b));\n  }\n  protected abstract scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T): T;\n\n  /**\n   * Computes a scalar times array operation broadcasted over the NDArray, c *\n   * A.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  scalarTimesArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: first argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.scalarTimesArrayInternal(c, a));\n  }\n  protected abstract scalarTimesArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an element-wise broadcasted multiplication of two matrices A and\n   * B. Will return a new matrix that is the max of A and B, where the smaller\n   * matrix will broadcast over the larger matrix.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D {\n    util.assert(\n        a.rank === 2,\n        `Error in elementWiseMulBroadcast: first argument must be ` +\n            `rank 2, but got rank ${a.rank}.`);\n    util.assert(\n        b.rank === 2,\n        `Error in elementWiseMulBroadcast: second argument must be ` +\n            `rank 2, but got rank ${b.rank}.`);\n    return this.track(this.elementWiseMulBroadcastInternal(a, b));\n  }\n  protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D):\n      Array2D;\n\n  /////////////////////\n  // Convolution ops //\n  /////////////////////\n\n  /**\n   * Computes a 2D convolution over the input x.\n   * @param x The input image, must be rank 3, of shape [rows, cols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param zeroPad The zero padding of each side of the input NDArray. Will pad\n   * equally on all sides.\n   */\n  conv2d(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2d: weights must be rank 4, but got rank ` +\n            `${weights.rank}.`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2d: biases must be rank 1, but got rank ` +\n              `${biases.rank}.`);\n    }\n\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2d: depth of input (${x.shape[2]}) must match  ` +\n            `input depth for weights ${weights.shape[2]}.`);\n\n\n    return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad));\n  }\n  protected abstract conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D;\n\n  /**\n   * Computes the backprop of a 2D convolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param stride The stride of the original convolution.\n   * @param pad The padding of the original convolution.\n   */\n  conv2dBackProp(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dBackProp: x must be rank 3, but got shape ` +\n            `${x.shape}.`);\n    util.assert(\n        dy.rank === 3,\n        `Error in conv2dBackProp: dy must be rank 3, but got shape ` +\n            `${dy.shape}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dBackProp: weights must be rank 4, but got shape ` +\n            `${weights.shape}.`);\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` +\n            `match input depth for weights (${weights.shape[2]}.`);\n    util.assert(\n        dy.shape[2] === weights.shape[3],\n        `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` +\n            `match output depth for weights (${weights.shape[3]}).`);\n\n    const backpropResult =\n        this.conv2dBackPropInternal(x, dy, weights, stride, pad);\n\n    this.track(backpropResult.db);\n    this.track(backpropResult.dw);\n    this.track(backpropResult.dx);\n\n    return backpropResult;\n  }\n  protected abstract conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D};\n\n  /**\n   * Computes the transposed 2D convolution of an image, also known as a\n   * deconvolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  conv2dTranspose(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dTranspose: x must be rank 3, but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dTranspose: weights must be rank 4, but got ` +\n            `rank ${weights.rank}`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2dTranspose: biases must be rank 1, but got ' +\n              'rank ${biases.rank}.`);\n    }\n    util.assert(\n        x.shape[2] === weights.shape[3],\n        `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` +\n            `match input depth for weights ${weights.shape[3]}.`);\n\n    return this.track(\n        this.conv2dTransposeInternal(x, weights, biases, stride, pad));\n  }\n  protected abstract conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D max pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.');\n    return this.track(this.maxPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the backprop of a max pool.\n   * @param dy The dy error.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPoolBackprop(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        dy.rank === 3,\n        `Error in maxPoolBackprop: dy must be rank 3 but got rank ` +\n            `${dy.rank}.`);\n    util.assert(\n        x.rank === 3,\n        `Error in maxPoolBackprop: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n\n    return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad));\n  }\n  protected abstract maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D min pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in minPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.minPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the 2D average pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.avgPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /*\n   * Bilinear resize a 3D array per each channel to a new 2D shape.\n   * @param x The input Array3D.\n   * @param newShape2D The new shape to resize the Array3D to. Each channel is\n   * resized individually.\n   * @param alignCorners An optional bool. Defaults to False. If true, rescale\n   * input by (new_height - 1) / (height - 1), which exactly aligns the 4\n   * corners of images and resized images. If false, rescale by new_height /\n   * height. Treat similarly the width dimension.\n   */\n  resizeBilinear3D(\n      x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`);\n    util.assert(\n        newShape2D.length === 2,\n        `Error in resizeBilinear3D: new shape must 2D, but got shape ` +\n            `${newShape2D}.`);\n    return this.track(\n        this.resizeBilinear3DInternal(x, newShape2D, alignCorners));\n  }\n  protected abstract resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D;\n\n  /**\n   * Batch normalization 3D. Mean, variance, scale, and offset can be of two\n   * shapes: 1) The same shape as the input: an Array3D. 2) In the common case,\n   * the depth dimension is the last dimension of x, so the values would be an\n   * Array1D of shape [depth].\n   * @param x The input NDArray.\n   * @param mean A mean NDArray.\n   * @param variance A variance NDArray.\n   * @param varianceEpsilon A small float number to avoid dividing by 0.\n   * @param scale A scale NDArray.\n   * @param offset An offset NDArray.\n   */\n  batchNormalization3D(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in batchNormalization3D: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        mean.rank === 3 || mean.rank === 1,\n        `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` +\n            `got rank ${mean.rank}.`);\n    util.assert(\n        variance.rank === 3 || variance.rank === 1,\n        `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` +\n            `but got rank ${variance.rank}.`);\n    if (scale != null) {\n      util.assert(\n          scale.rank === 3 || scale.rank === 1,\n          `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` +\n              `but got rank ${scale!.rank}.`);\n    }\n    if (offset != null) {\n      util.assert(\n          offset.rank === 3 || offset.rank === 1,\n          `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` +\n              `but got rank ${offset!.rank}.`);\n    }\n\n    return this.track(this.batchNormalization3DInternal(\n        x, mean, variance, varianceEpsilon, scale, offset));\n  }\n  protected abstract batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D;\n}\n\nexport enum MatrixOrientation {\n  REGULAR,\n  TRANSPOSED\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../math/conv_util';\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2D_util from './copy2d_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport class NDArrayMathCPU extends NDArrayMath {\n  constructor(safeMode = false) {\n    super(safeMode);\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    return NDArray.make<T>(\n        ndarray.shape, {values: new Float32Array(ndarray.getValues())});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    return this.cloneInternal(ndarray).reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = Array2D.zeros(sizeRowCol);\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol);\n    const srcValues = source.getValues();\n    const dstValues = dest.getValues();\n    const n = sourceSizeRowCol[0] * sourceSizeRowCol[1];\n    for (let i = 0; i < n; ++i) {\n      const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]);\n      const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]);\n      const srcOff = srcRow * source.shape[1] + srcCol;\n      const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]);\n      const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]);\n      const dstOff = dstRow * dest.shape[1] + dstCol;\n      dstValues[dstOff] = srcValues[srcOff];\n    }\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const outputShape =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const values = NDArray.zeros<Array3D>(outputShape);\n\n    for (let i = 0; i < outputShape[0]; i++) {\n      for (let j = 0; j < outputShape[1]; j++) {\n        for (let k = 0; k < outputShape[2]; k++) {\n          // Shader begins.\n          const index: [number, number, number] = [i, j, k];\n          let value: number;\n          if (index[axis] < x1.shape[axis]) {\n            value = x1.get(i, j, k);\n          } else {\n            index[axis] -= x1.shape[axis];\n            const [i2, j2, k2] = index;\n            value = x2.get(i2, j2, k2);\n          }\n\n          values.set(value, i, j, k);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const resultValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < resultValues.length; ++i) {\n      resultValues[i] = cVal + aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: resultValues});\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    const cValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    const c1Val = c1.get();\n    const c2Val = c2.get();\n    for (let i = 0; i < cValues.length; ++i) {\n      cValues[i] = c1Val * aValues[i] + c2Val * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: cValues});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cVal * aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const negA = this.negInternal(a);\n    const result = this.scalarPlusArrayInternal(c, negA);\n\n    negA.dispose();\n\n    return result;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    const negC = this.negInternal(c);\n    const result = this.scalarPlusArrayInternal(negC, a);\n\n    negC.dispose();\n\n    return result;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a);\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.ONE, b);\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.NEG_ONE, b);\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n\n    const leftDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const rightDim =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n\n    const normalGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(i, j);\n    const transposedGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(j, i);\n\n    const aGetter = (aOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const bGetter = (bOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const values = new Float32Array(leftDim * rightDim);\n    let index = 0;\n\n    for (let i = 0; i < leftDim; ++i) {\n      for (let j = 0; j < rightDim; ++j) {\n        let sum = 0;\n        for (let k = 0; k < sharedDim; ++k) {\n          // TODO: optimize CPU matmul.\n          sum += aGetter(a, i, k) * bGetter(b, k, j);\n        }\n        values[index++] = sum;\n      }\n    }\n    return Array2D.new([leftDim, rightDim], values);\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    const maxRow = Math.max(a.shape[0], b.shape[0]);\n    const maxCol = Math.max(a.shape[1], b.shape[1]);\n\n    const values = new Float32Array(maxRow * maxCol);\n    let index = 0;\n    for (let row = 0; row < maxRow; row++) {\n      for (let col = 0; col < maxCol; col++) {\n        values[index++] = a.get(row % a.shape[0], col % a.shape[1]) *\n            b.get(row % b.shape[0], col % b.shape[1]);\n      }\n    }\n    return Array2D.new([maxRow, maxCol], values);\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cValue / aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / cValue;\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    let sum = 0;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      sum += values[i];\n    }\n    return Scalar.new(sum);\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    let min = Number.MAX_VALUE;\n    let minIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n        minIndex = i;\n      }\n    }\n    return Scalar.new(minIndex);\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    let max = Number.NEGATIVE_INFINITY;\n    let maxIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n    return Scalar.new(maxIndex);\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    const argMax1 = this.argMaxInternal(x1).get();\n    const argMax2 = this.argMaxInternal(x2).get();\n    if (isNaN(argMax1) || isNaN(argMax2)) {\n      return Scalar.new(NaN);\n    }\n    return Scalar.new(+(argMax1 === argMax2));\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    const values = ndarray.getValues();\n    const valuesAndIndices: Array<{value: number, index: number}> = [];\n    for (let i = 0; i < values.length; i++) {\n      valuesAndIndices.push({value: values[i], index: i});\n    }\n    valuesAndIndices.sort((a, b) => {\n      return b.value - a.value;\n    });\n    const topkValues = new Float32Array(k);\n    const topkIndices = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n      topkValues[i] = valuesAndIndices[i].value;\n      topkIndices[i] = valuesAndIndices[i].index;\n    }\n    return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)};\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let min = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n      }\n    }\n    return Scalar.new(min);\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let max = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n      }\n    }\n    return Scalar.new(max);\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      newValues[i] = Math.exp(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      newValues[i] = Math.log(value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const xMax = this.max(ndarray);\n    const a = this.arrayMinusScalar(ndarray, xMax);\n    const b = this.exp(a);\n    const c = this.sum(b);\n    const d = this.log(c);\n    const result = this.add(xMax, d);\n\n    xMax.dispose();\n    a.dispose();\n    b.dispose();\n    c.dispose();\n    d.dispose();\n\n    return result;\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.max(0, values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = 1 / (1 + Math.exp(-values[i]));\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = util.tanh(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.sin(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    const [xRows, xCols, inputDepth] = x.shape;\n    const fieldSize = weights.shape[0];\n    const outputDepth = weights.shape[3];\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fieldSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fieldSize + xCCorner);\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              for (let d1 = 0; d1 < inputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight = weights.get(wR, wC, d1, d2);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = (biases != null) ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad);\n    return {dx, db, dw};\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const fSize = weights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR - pad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / origStride));\n        const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride);\n\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC - pad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / origStride));\n          const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride);\n\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR * origStride - xRCorner;\n\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC * origStride - xCCorner;\n\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = biases != null ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeShaderLike(\n      x: Array3D, origWeights: Array4D, origStride: number,\n      origPad: number): Array3D {\n    const fSize = origWeights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = origWeights.shape[2];\n    const origOutputDepth = origWeights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          // Shader code begins.\n          const xRCorner = yR - pad;\n          const xCCorner = yC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const xR = (xRCorner + wR) / origStride;\n            if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const xC = (xCCorner + wC) / origStride;\n              if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) {\n                continue;\n              }\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          y.set(dotProd, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    const dW = Array4D.zeros(weightsShape);\n\n    const yNumRows = dY.shape[0];\n    const yNumCols = dY.shape[1];\n    const xNumRows = x.shape[0];\n    const xNumCols = x.shape[1];\n\n    for (let wR = 0; wR < fSize; ++wR) {\n      const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride));\n      const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride);\n\n      for (let wC = 0; wC < fSize; ++wC) {\n        const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride));\n        const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride);\n\n        for (let d1 = 0; d1 < inputDepth; ++d1) {\n          for (let d2 = 0; d2 < outputDepth; ++d2) {\n            // Need to convolve.\n            let dotProd = 0;\n            for (let yR = yRMin; yR < yRMax; ++yR) {\n              const xR = wR + yR * stride - zeroPad;\n              for (let yC = yCMin; yC < yCMax; ++yC) {\n                const xC = wC + yC * stride - zeroPad;\n                dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2);\n              }\n            }\n            dW.set(dotProd, wR, wC, d1, d2);\n          }\n        }\n      }\n    }\n    return dW;\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const numRows = dY.shape[0];\n    const numCols = dY.shape[1];\n    const values = new Float32Array(outputDepth);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      let sum = 0;\n      for (let r = 0; r < numRows; ++r) {\n        for (let c = 0; c < numCols; ++c) {\n          sum += dY.get(r, c, d2);\n        }\n      }\n      values[d2] = sum;\n    }\n    return Array1D.new(values);\n  }\n\n  protected switchDimInternal<T extends NDArray>(t: T, newDim: number[]): T {\n    const newShape: number[] = new Array(t.rank);\n    for (let i = 0; i < newShape.length; i++) {\n      newShape[i] = t.shape[newDim[i]];\n    }\n    const resultValues = new Float32Array(t.size);\n    const values = t.getValues();\n    const result = NDArray.make<T>(newShape, {values: resultValues});\n    for (let i = 0; i < t.size; ++i) {\n      const loc = t.indexToLoc(i);\n\n      // Permute location.\n      const newLoc: number[] = new Array(loc.length);\n      for (let i = 0; i < newLoc.length; i++) {\n        newLoc[i] = loc[newDim[i]];\n      }\n\n      const newIndex = result.locToIndex(newLoc);\n      resultValues[newIndex] = values[i];\n    }\n    return result;\n  }\n\n  private pool(\n      x: Array3D, fSize: number, stride: number, pad: number,\n      poolType: 'max'|'min'|'avg') {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, depth], fSize, depth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n\n\n          let minMaxValue =\n              (poolType === 'max' ? Number.NEGATIVE_INFINITY :\n                                    Number.POSITIVE_INFINITY);\n          let avgValue = 0;\n\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (isNaN(pixel)) {\n                minMaxValue = NaN;\n                avgValue = NaN;\n                break;\n              }\n              if ((poolType === 'max' && pixel > minMaxValue) ||\n                  (poolType === 'min' && pixel < minMaxValue)) {\n                minMaxValue = pixel;\n              } else if (poolType === 'avg') {\n                avgValue += pixel / (fSize * fSize);\n              }\n            }\n            if (isNaN(minMaxValue)) {\n              break;\n            }\n          }\n          y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'max');\n  }\n\n  maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad);\n    const maxPositions = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < outputShape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < outputShape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n          let maxValue = Number.NEGATIVE_INFINITY;\n          let maxPosition = -1;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (pixel > maxValue) {\n                maxValue = pixel;\n                maxPosition = wR * fSize + wC;\n              }\n            }\n          }\n          maxPositions.set(maxPosition, yR, yC, d);\n        }\n      }\n    }\n    return maxPositions;\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad);\n    const pad = fSize - 1 - origPad;\n    const [dyRows, dyCols, depth] = dy.shape;\n\n    // Dilate the input.\n    const dyRowsDilated = (dyRows - 1) * origStride + 1;\n    const dxColsDilated = (dyCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad);\n    const dx = Array3D.zeros(outputShape);\n\n    for (let d = 0; d < depth; ++d) {\n      for (let dxR = 0; dxR < dx.shape[0]; ++dxR) {\n        for (let dxC = 0; dxC < dx.shape[1]; ++dxC) {\n          // Shader code begins.\n          const dyRCorner = dxR - pad;\n          const dyCCorner = dxC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const dyR = (dyRCorner + wR) / origStride;\n            if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const dyC = (dyCCorner + wC) / origStride;\n              if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) {\n                continue;\n              }\n              const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d);\n              const curPos = wR * fSize + wC;\n\n              const mask = maxPos === curPos ? 1 : 0;\n              if (mask === 0) {\n                continue;\n              }\n\n              const pixel = dy.get(dyR, dyC, d);\n              dotProd += pixel * mask;\n            }\n          }\n          dx.set(dotProd, dxR, dxC, d);\n        }\n      }\n    }\n    return dx;\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'min');\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'avg');\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]);\n\n    const effectiveInputSize =\n        alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape;\n    const effectiveOutputSize = alignCorners ?\n        [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] :\n        output.shape;\n    for (let r = 0; r < output.shape[0]; r++) {\n      for (let c = 0; c < output.shape[1]; c++) {\n        for (let d = 0; d < output.shape[2]; d++) {\n          // Begin shader.\n\n          // Compute the fractional index of the source.\n          const sourceFracRow =\n              (effectiveInputSize[0]) * r / (effectiveOutputSize[0]);\n          const sourceFracCol =\n              (effectiveInputSize[1]) * c / (effectiveOutputSize[1]);\n\n          const sourceRowFloor = Math.floor(sourceFracRow);\n          const sourceRowCeil =\n              Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow));\n          const sourceColFloor = Math.floor(sourceFracCol);\n          const sourceColCeil =\n              Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol));\n\n          const topLeft = x.get(sourceRowFloor, sourceColFloor, d);\n          const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d);\n          const topRight = x.get(sourceRowFloor, sourceColCeil, d);\n          const bottomRight = x.get(sourceRowCeil, sourceColCeil, d);\n\n          const rowFrac = sourceFracRow - sourceRowFloor;\n          const colFrac = sourceFracCol - sourceColFloor;\n\n          const top = topLeft + (topRight - topLeft) * colFrac;\n          const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;\n          const newValue = top + (bottom - top) * rowFrac;\n\n          output.set(newValue, r, c, d);\n        }\n      }\n    }\n\n    return output;\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xValues = x.getValues();\n    const meanValues = mean.getValues();\n    const varianceValues = variance.getValues();\n    const scaleValues = scale ? scale.getValues() : new Float32Array([1]);\n    const offsetValues = offset ? offset.getValues() : new Float32Array([0]);\n    const outValues = new Float32Array(xValues.length);\n\n    for (let i = 0; i < xValues.length; i++) {\n      outValues[i] = offsetValues[i % offsetValues.length] +\n          (xValues[i] - meanValues[i % meanValues.length]) *\n              scaleValues[i % scaleValues.length] /\n              Math.sqrt(\n                  varianceValues[i % varianceValues.length] + varianceEpsilon);\n    }\n    return NDArray.make<Array3D>(x.shape, {values: outValues});\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as conv_util from './conv_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport * as ndarray from './ndarray';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\nimport * as addscaledmat_gpu from './webgl/addscaledmat_gpu';\nimport * as addsubmuldiv_gpu from './webgl/addsubmuldiv_gpu';\nimport {OperandType} from './webgl/addsubmuldiv_gpu';\nimport * as argmaxequals_gpu from './webgl/argmaxequals_gpu';\nimport * as argminmax_gpu from './webgl/argminmax_gpu';\nimport * as avg_pool_gpu from './webgl/avg_pool_gpu';\nimport * as batchnorm_gpu from './webgl/batchnorm_gpu';\nimport * as concat3d_gpu from './webgl/concat3d_gpu';\nimport * as conv_backprop_gpu from './webgl/conv_backprop_gpu';\nimport * as conv_gpu from './webgl/conv_gpu';\nimport * as copy_gpu from './webgl/copy_gpu';\nimport * as exp_gpu from './webgl/exp_gpu';\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport * as gpgpu_util from './webgl/gpgpu_util';\nimport * as log_gpu from './webgl/log_gpu';\nimport * as logsumexp_gpu from './webgl/logsumexp_gpu';\nimport * as max_pool_backprop_gpu from './webgl/max_pool_backprop_gpu';\nimport * as max_pool_gpu from './webgl/max_pool_gpu';\nimport * as min_pool_gpu from './webgl/min_pool_gpu';\nimport * as minmax_gpu from './webgl/minmax_gpu';\nimport * as mulmat_gpu from './webgl/mulmat_gpu';\nimport * as neg_gpu from './webgl/neg_gpu';\nimport * as pool_gpu from './webgl/pool_gpu';\nimport * as reducesum_gpu from './webgl/reducesum_gpu';\nimport * as relu_gpu from './webgl/relu_gpu';\nimport * as reshape_gpu from './webgl/reshape_gpu';\nimport * as resize_bilinear_gpu from './webgl/resize_bilinear_gpu';\nimport * as shader_compiler from './webgl/shader_compiler';\nimport * as sigmoid_gpu from './webgl/sigmoid_gpu';\nimport * as step_gpu from './webgl/step_gpu';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as trig_gpu from './webgl/trig_gpu';\nimport * as webgl_util from './webgl/webgl_util';\n\nconst ARGMAX_PROG = 'argmax';\nconst ARGMAX_EQUALS_PROG = 'argmaxequals';\nconst ARGMIN_PROG = 'argmin';\n\nconst BATCHNORM_PROG = 'batchnorm';\n\nconst COPY_PROG = 'copy';\nconst CONCAT_PROG = 'concat';\n\n// Matrix algebra.\nconst ADD_SCALED_MAT_PROG = 'addscaledmat';\nconst MATMUL_PROG = 'matmul';\n\n// Element-wise ops.\nconst RELU_PROG = 'relu';\nconst TANH_PROG = 'tanh';\nconst SIN_PROG = 'sin';\nconst SIGMOID_PROG = 'sigmoid';\nconst MAX_PROG = 'max';\nconst MIN_PROG = 'min';\nconst NEG_PROG = 'neg';\nconst EXP_PROG = 'exp';\nconst LOG_PROG = 'log';\nconst SUM_PROG = 'sum';\nconst STEP_PROG = 'step';\nconst LOGSUMEXP_PROG = 'logsumexp';\nconst RESHAPE_PROG = 'reshape';\nconst ADD_SUM_MUL_DIV_PROG = 'addsummuldiv';\n\n// Convolution.\nconst CONV2D_PROG = 'conv';\nconst CONV2D_TRANSPOSE_PROG = 'conv_transpose';\nconst CONV2D_DERW_PROG = 'conv_derw';\nconst CONV2D_DERB_PROG = 'conv_derb';\nconst MAX_POOL_PROG = 'maxpool';\nconst MAX_POOL_POSITIONS_PROG = 'maxpool_posn';\nconst MAX_POOL_BACKPROP_PROG = 'maxpool_backprop';\nconst MIN_POOL_PROG = 'minpool';\nconst AVG_POOL_PROG = 'avgpool';\n\nconst RESIZE_BILINEAR_PROG = 'resizebilin';\n\nfunction makeCopyProgramName(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  const shapeName = `${sourceShapeRowCol[0]}_${sourceShapeRowCol[1]}`;\n  const srcSizeName = `${sourceSizeRowCol[0]}_${sourceSizeRowCol[1]}`;\n  const dstSizeName = `${destSizeRowCol[0]}_${destSizeRowCol[1]}`;\n  return `${COPY_PROG}_${shapeName}_${srcSizeName}_${dstSizeName}`;\n}\n\nexport class NDArrayMathGPU extends NDArrayMath {\n  private gpgpu: GPGPUContext;\n  private textureManager: TextureManager;\n  private programCache: {[key: string]: WebGLProgram} = {};\n  private gpgpuCreatedLocally: boolean;\n\n  constructor(gpgpu?: GPGPUContext, safeMode = true) {\n    super(safeMode);\n    if (gpgpu == null) {\n      const gl = gpgpu_util.createWebGLContext();\n      this.gpgpu = new GPGPUContext(gl);\n      this.gpgpuCreatedLocally = true;\n    } else {\n      this.gpgpu = gpgpu;\n      this.gpgpuCreatedLocally = false;\n    }\n\n    this.textureManager = new TextureManager(this.gpgpu);\n\n    ndarray.initializeGPU(this.gpgpu, this.textureManager);\n  }\n\n  getGPGPUContext(): GPGPUContext {\n    return this.gpgpu;\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC),\n        () => copy_gpu.getFragmentShaderSource(\n            textureShapeRC, textureShapeRC, textureShapeRC));\n\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    copy_gpu.copy(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0],\n        textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    let newTexShape: [number, number];\n\n    switch (newShape.length) {\n      case 0:\n        newTexShape = [1, 1];\n        break;\n      case 1:\n        newTexShape = [newShape[0], 1];\n        break;\n      case 2:\n        newTexShape = [newShape[0], newShape[1]];\n        break;\n      case 3:\n        newTexShape = [newShape[0], newShape[1] * newShape[2]];\n        break;\n      default:\n        throw Error(\n            `Reshapes into ${newShape.length}-dim ndarray is not yet ` +\n            `supported on GPU`);\n    }\n\n    const actualTexShape = ndarray.getTextureShapeRC(newTexShape);\n    let clonedArray: T1;\n    if (!util.arraysEqual(actualTexShape, newTexShape)) {\n      clonedArray = this.reshapeTexture(ndarray, newTexShape);\n    } else {\n      clonedArray = this.cloneInternal(ndarray);\n    }\n    return clonedArray.reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = NDArray.make<Array2D>(sizeRowCol, {\n      texture: this.textureManager.acquireTexture(sizeRowCol),\n      textureShapeRC: sizeRowCol\n    });\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    const sourceShapeRC = source.getTextureShapeRC();\n    const destShapeRC = dest.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol),\n        () => copy_gpu.getFragmentShaderSource(\n            sourceShapeRC, sourceSizeRowCol, destSizeRowCol));\n\n    copy_gpu.copy(\n        this.gpgpu, program, source.getTexture(), sourceShapeRC,\n        sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC,\n        destBeginRowCol, destSizeRowCol);\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const x1TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x1.shape);\n    const x2TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x2.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC);\n    let cleanupX1 = false;\n    if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) {\n      x1 = this.reshapeTexture(x1, x1TexShapeRC);\n      cleanupX1 = true;\n    }\n    const actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC);\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) {\n      x2 = this.reshapeTexture(x2, x2TexShapeRC);\n      cleanupX2 = true;\n    }\n\n    const resultShapeRCD =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const program = this.getAndSaveProgram(\n        `${CONCAT_PROG}_${x1.shape}_${x2.shape}_${axis}`,\n        () => concat3d_gpu.getFragmentShaderSource(\n            x1.shape, x2.shape, resultShapeRCD, axis));\n\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    concat3d_gpu.concat3D(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX1) {\n      x1.dispose();\n    }\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '+', OperandType.MATRIX) as T;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    return this.addSubMulDiv(\n        a, c, a.shape, OperandType.MATRIX, '-', OperandType.SCALAR) as T;\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '-', OperandType.MATRIX) as T;\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    let cleanupB = false;\n    if (!this.doGPUShapesMatch(a, b)) {\n      b = this.reshapeTexture(b, a.getTextureShapeRC());\n      cleanupB = true;\n    }\n\n    const program = this.getAndSaveProgram(\n        ADD_SCALED_MAT_PROG, () => addscaledmat_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    addscaledmat_gpu.addScaledMatrices(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n    // Bring the result back to the original shape.\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '*', OperandType.MATRIX) as T;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    const program = this.getAndSaveProgram(\n        NEG_PROG, () => neg_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    neg_gpu.neg(\n        this.gpgpu, program, a.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  private reshapeTexture<T extends NDArray>(a: T, newTextureShape: [\n    number, number\n  ]): T {\n    const aTexShape = a.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        RESHAPE_PROG, () => reshape_gpu.getFragmentShaderSource());\n\n    const resultTexture = this.textureManager.acquireTexture(newTextureShape);\n    reshape_gpu.reshape(\n        this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1],\n        resultTexture, newTextureShape[0], newTextureShape[1]);\n\n    return NDArray.make<T>(\n        a.shape, {texture: resultTexture, textureShapeRC: newTextureShape});\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const outerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const outerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n    const outShape: [number, number] = [outerShapeA, outerShapeB];\n    const outTexShape =\n        webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape);\n    const outTexture = this.textureManager.acquireTexture(outTexShape);\n    const out = new Array2D(\n        outShape, {texture: outTexture, textureShapeRC: outTexShape});\n\n    const key = shader_compiler.makeShaderKey([a, b], out);\n    const program = this.getAndSaveProgram(\n        `${MATMUL_PROG}_${key}_${aOrientation}_${bOrientation}`,\n        () => mulmat_gpu.getFragmentShader(\n            a, b, out, aOrientation, bOrientation));\n\n    mulmat_gpu.multiplyMatrix(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture,\n        outTexShape);\n\n    return out;\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '*', OperandType.MATRIX) as T;\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xTexShape = x.getTextureShapeRC();\n\n    let cleanupMean = false;\n    const preferredMeanTexShape: [number, number] =\n        mean.rank === 1 ? [1, mean.size] : xTexShape;\n    let meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) {\n      mean = this.reshapeTexture(mean, preferredMeanTexShape);\n      meanTexShape = preferredMeanTexShape;\n      cleanupMean = true;\n    }\n\n    let cleanupVariance = false;\n    const preferredVarianceTexShape: [number, number] =\n        variance.rank === 1 ? [1, variance.size] : xTexShape;\n    let varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) {\n      variance = this.reshapeTexture(variance, preferredVarianceTexShape);\n      varianceTexShape = preferredVarianceTexShape;\n      cleanupVariance = true;\n    }\n\n    let scaleTexShape: [number, number]|null = null;\n    let cleanupScale = false;\n    if (scale != null) {\n      const preferredScaleTexShape: [number, number] =\n          scale.rank === 1 ? [1, scale.size] : xTexShape;\n\n      scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape);\n      if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) {\n        scale = this.reshapeTexture(scale, preferredScaleTexShape);\n        scaleTexShape = preferredScaleTexShape;\n        cleanupScale = true;\n      }\n    }\n\n    let offsetTexShape: [number, number]|null = null;\n    let cleanupOffset = false;\n    if (offset != null) {\n      const preferredOffsetTexShape: [number, number] =\n          offset.rank === 1 ? [1, offset.size] : xTexShape;\n\n      offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape);\n      if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) {\n        offset = this.reshapeTexture(offset, preferredOffsetTexShape);\n        offsetTexShape = preferredOffsetTexShape;\n        cleanupOffset = true;\n      }\n    }\n\n    const resultTexShape: [number, number] = x.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${BATCHNORM_PROG}_${xTexShape}_${meanTexShape}_${varianceTexShape}_` +\n            `${scaleTexShape!}_${offsetTexShape!}_${varianceEpsilon}`,\n        () => batchnorm_gpu.getFragmentShaderSource(\n            xTexShape, meanTexShape, varianceTexShape, offsetTexShape,\n            scaleTexShape, varianceEpsilon));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    batchnorm_gpu.batchNormalization(\n        this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(),\n        meanTexShape, variance.getTexture(), varianceTexShape,\n        offset != null ? offset.getTexture() : null,\n        offset != null ? offsetTexShape : null,\n        scale != null ? scale.getTexture() : null,\n        scale != null ? scaleTexShape : null, resultTexture, resultTexShape);\n\n    if (cleanupMean) {\n      mean.dispose();\n    }\n    if (cleanupVariance) {\n      variance.dispose();\n    }\n    if (cleanupScale) {\n      scale!.dispose();\n    }\n    if (cleanupOffset) {\n      offset!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        x.shape, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  protected switchDimInternal<T extends NDArray>(a: T, newDim: number[]): T {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${SUM_PROG}_${numRows}_${numColumns}`,\n        () => reducesum_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMIN_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    // If the texture shapes doesn't match, do a physical reshape so they do.\n    const actualX1TexShape = x1.getTextureShapeRC();\n    const actualX2TexShape = x2.getTextureShapeRC();\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) {\n      x2 = this.reshapeTexture(x2, actualX1TexShape);\n      cleanupX2 = true;\n    }\n\n    const textureShapeRC = x1.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_EQUALS_PROG}_${numRows}_${numColumns}`,\n        () => argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(\n            numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argmaxequals_gpu.argMaxEquals(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows,\n        numColumns, resultTexture);\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    throw new Error('topK GPU not yet implemented!');\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MIN_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MAX_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '/', OperandType.MATRIX) as T;\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    return this.addSubMulDiv(\n               c, a, a.shape, OperandType.SCALAR, '/', OperandType.MATRIX) as T;\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    return this.addSubMulDiv(\n               a, c, a.shape, OperandType.MATRIX, '/', OperandType.SCALAR) as T;\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '+', OperandType.MATRIX) as T;\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '-', OperandType.MATRIX) as T;\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const [numRows, numColumns] = ndarray.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${LOGSUMEXP_PROG}_${numRows}_${numColumns}`,\n        () => logsumexp_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const result =\n        new Scalar({texture: this.textureManager.acquireTexture([1, 1])});\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        result.getTexture());\n\n    return result;\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        EXP_PROG, () => exp_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    exp_gpu.exp(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        LOG_PROG, () => log_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n    log_gpu.log(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        RELU_PROG, () => relu_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    relu_gpu.relu(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIGMOID_PROG, () => sigmoid_gpu.getSigmoidFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    sigmoid_gpu.sigmoid(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        TANH_PROG, () => trig_gpu.getTanhFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.tanh(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIN_PROG, () => trig_gpu.getSinFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.sin(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        STEP_PROG, () => step_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    step_gpu.step(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    const fieldSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const progKey = [\n      CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_gpu.getFragmentShaderSource(\n          x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(outputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    const resultShape = conv_util.computeOutputShape3D(\n        x.shape, fieldSize, outputDepth, stride, zeroPad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_gpu.convolve(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB && biases != null) {\n      biases.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const yTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupX = false;\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dy.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dy = this.reshapeTexture(dy, yTexShape);\n      cleanupY = true;\n    }\n\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(\n        dy, weights, null /** biases */, stride, pad);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupY) {\n      dy.dispose();\n    }\n    return {dx, db, dw};\n  }\n\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const fieldSize = weights.shape[0];\n\n    const progKey = [\n      CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride,\n      origPad, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderConvTransposeSource(\n          x.shape, fieldSize, origInputDepth, origStride, origPad,\n          biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape = conv_util.computeWeightsTexShape(\n        origInputDepth, origOutputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(origInputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBiasTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    // Figure out the output shape by dilating the input.\n    const dilatedRC =\n        conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride);\n    const pad = fieldSize - 1 - origPad;\n    const resultShape = conv_util.computeOutputShape3D(\n        [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize,\n        origInputDepth, 1, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.convTranspose(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB) {\n      biases!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const progKey = [\n      CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerWeightsSource(\n          x.shape, fSize, outputDepth, stride, zeroPad);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const yShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, outputDepth, stride, zeroPad);\n    const yTexShape = conv_util.computeTexShapeFrom3D(yShape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derWeights(\n        this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    return NDArray.make<Array4D>(\n        weightsShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const progKey = [CONV2D_DERB_PROG, dY.shape].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape);\n    });\n    const yTexShape = conv_util.computeTexShapeFrom3D(dY.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape = conv_util.computeBiasesTexShape(outputDepth);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derBias(\n        this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape);\n\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    return NDArray.make<Array1D>(\n        [outputDepth], {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  private pool(\n      program: WebGLProgram, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    const resultShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const poolResultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    pool_gpu.poolCommon(\n        this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: poolResultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const maxPoolProgKey =\n        [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, () => {\n      return max_pool_gpu.getFragmentShaderMaxPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(maxPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const minPoolProgKey =\n        [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const minPoolProgram = this.getAndSaveProgram(minPoolProgKey, () => {\n      return min_pool_gpu.getFragmentShaderMinPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(minPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const avgPoolProgKey =\n        [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, () => {\n      return avg_pool_gpu.getFragmentShaderAvgPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(avgPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPoolPositionsProgKey = [\n      MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad\n    ].join('_');\n    const maxPoolPositionsProgram =\n        this.getAndSaveProgram(maxPoolPositionsProgKey, () => {\n          return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(\n              x.shape, fSize, origStride, origPad);\n        });\n\n    const maxPoolResultShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, x.shape[2], origStride, origPad);\n    const maxPoolResultTexShape =\n        conv_util.computeTexShapeFrom3D(maxPoolResultShape);\n    const maxPoolPositionsResultTex =\n        this.textureManager.acquireTexture(maxPoolResultTexShape);\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    max_pool_gpu.maxPoolCommon(\n        this.gpgpu, maxPoolPositionsProgram, x.getTexture(),\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    const maxPoolBackpropProgKey = [\n      MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad\n    ].join('_');\n    const program = this.getAndSaveProgram(maxPoolBackpropProgKey, () => {\n      return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(\n          dy.shape, fSize, origStride, origPad);\n    });\n\n    const dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualDyTexShape = dy.getTextureShapeRC(dyTexShape);\n    let cleanupDy = false;\n    if (!util.arraysEqual(actualDyTexShape, dyTexShape)) {\n      dy = this.reshapeTexture(dy, dyTexShape);\n      cleanupDy = true;\n    }\n\n    const dilatedDyRC =\n        conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride);\n    const pad = fSize - 1 - origPad;\n    const resultShapeRCD = conv_util.computeOutputShape3D(\n        [dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1,\n        pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    max_pool_backprop_gpu.maxPoolBackprop(\n        this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex,\n        resultTex, resultTexShape);\n\n    if (cleanupDy) {\n      dy.dispose();\n    }\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    this.textureManager.releaseTexture(\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const programKey =\n        [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_');\n\n    const newShapeRCD: [number, number, number] =\n        [newShape2D[0], newShape2D[1], x.shape[2]];\n    const resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD);\n\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => resize_bilinear_gpu.getFragmentShaderSource(\n            x.shape, newShape2D, alignCorners));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    resize_bilinear_gpu.resizeBilinear(\n        this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape);\n\n    return NDArray.make<Array3D>(\n        newShapeRCD, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  private getAndSaveProgram(programKey: string, getShaderSource: () => string):\n      WebGLProgram {\n    if (!(programKey in this.programCache)) {\n      this.programCache[programKey] =\n          this.gpgpu.createProgram(getShaderSource());\n    }\n    return this.programCache[programKey];\n  }\n\n  private addSubMulDiv(\n      a: NDArray, b: NDArray, resultShape: number[],\n      operandA: addsubmuldiv_gpu.OperandType,\n      opType: addsubmuldiv_gpu.Operation,\n      operandB: addsubmuldiv_gpu.OperandType): NDArray {\n    let cleanupB = false;\n\n    const aOrientation = MatrixOrientation.REGULAR;\n    let bOrientation = MatrixOrientation.REGULAR;\n\n    let logicalBTexShape: [number, number];\n\n    if (operandA === OperandType.MATRIX && operandB === OperandType.MATRIX) {\n      util.assertShapesMatch(a.shape, b.shape);\n\n      if (a.inGPU()) {\n        // Prefer B to have the shape of A.\n        b.getTextureShapeRC(a.getTextureShapeRC());\n      } else if (b.inGPU()) {\n        // Prefer A to have the shape of B.\n        a.getTextureShapeRC(b.getTextureShapeRC());\n      }\n\n      const aTexShape = a.getTextureShapeRC();\n      const bTexShape = b.getTextureShapeRC();\n      logicalBTexShape = bTexShape;\n\n      if (a.rank === 1) {\n        // When dealing with vectors, we can sample in transposed way without\n        // the need to do physical reshape.\n        if (!util.arraysEqual(bTexShape, aTexShape)) {\n          bOrientation = MatrixOrientation.TRANSPOSED;\n          logicalBTexShape = [bTexShape[1], bTexShape[0]];\n        }\n      }\n\n      if (!util.arraysEqual(aTexShape, logicalBTexShape)) {\n        b = this.reshapeTexture(b, aTexShape);\n        bOrientation = MatrixOrientation.REGULAR;\n        logicalBTexShape = b.getTextureShapeRC();\n        cleanupB = true;\n      }\n    } else {\n      logicalBTexShape = b.getTextureShapeRC();\n    }\n\n    const aTexShape = a.getTextureShapeRC();\n    const bTexShape = b.getTextureShapeRC();\n\n    const programKey = [\n      ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB,\n      bOrientation\n    ].join('_');\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => addsubmuldiv_gpu.getFragmentShaderSource(\n            operandA, aOrientation, opType, operandB, bOrientation));\n\n    const resultTextureShape: [number, number] = [\n      Math.max(aTexShape[0], logicalBTexShape[0]),\n      Math.max(aTexShape[1], logicalBTexShape[1])\n    ];\n\n    const resultTexture =\n        this.textureManager.acquireTexture(resultTextureShape);\n\n    addsubmuldiv_gpu.addSubMulDiv(\n        this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(),\n        bTexShape, resultTexture, resultTextureShape);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n\n    return NDArray.make(\n        resultShape,\n        {texture: resultTexture, textureShapeRC: resultTextureShape});\n  }\n\n  private doGPUShapesMatch(a: NDArray, b: NDArray): boolean {\n    util.assertShapesMatch(a.shape, b.shape);\n    if (a.inGPU()) {\n      // Prefer B to have the shape of A.\n      b.getTextureShapeRC(a.getTextureShapeRC());\n    } else if (b.inGPU()) {\n      // Prefer A to have the shape of B.\n      a.getTextureShapeRC(b.getTextureShapeRC());\n    }\n    return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC());\n  }\n\n  getTextureManager(): TextureManager {\n    return this.textureManager;\n  }\n\n  dispose() {\n    for (const programKey in this.programCache) {\n      if (this.programCache.hasOwnProperty(programKey)) {\n        this.gpgpu.deleteProgram(this.programCache[programKey]);\n      }\n    }\n    this.textureManager.dispose();\n\n    if (this.gpgpuCreatedLocally) {\n      this.gpgpu.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as webgl_util from './webgl/webgl_util';\n\n// These global variables need to be initialized to null so that closure knows\n// not to seal them.\n/** @hidden */\nexport let GPGPU: GPGPUContext = null!;\n/** @hidden */\nexport let TEXTURE_MANAGER: TextureManager = null!;\n\n/** @hidden */\nexport interface NDArrayData {\n  values?: Float32Array;\n  texture?: WebGLTexture;\n  /** [rows, columns] shape of the texture. */\n  textureShapeRC?: [number, number];\n}\n\n/** @hidden */\nexport function initializeGPU(\n    gpgpu: GPGPUContext, textureManager: TextureManager) {\n  GPGPU = gpgpu;\n  TEXTURE_MANAGER = textureManager;\n}\n\nfunction throwIfGPUNotInitialized() {\n  if (GPGPU == null || TEXTURE_MANAGER == null) {\n    throw new Error('GPU not intialized.');\n  }\n}\n\nexport class NDArray {\n  /** The shape of the ndarray. */\n  shape: number[];\n  /** Number of elements in the ndarray. */\n  size: number;\n\n  /**\n   * Number of elements to skip in each dimension when indexing. See\n   * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html\n   */\n  protected strides: number[];\n\n  private data: NDArrayData;\n\n  protected constructor(shape: number[], data: NDArrayData) {\n    // Sanity checks.\n    util.assert(\n        data.values != null || data.texture != null,\n        'Either `values` or `texture` must be defined');\n\n    util.assert(\n        data.texture == null || (data.textureShapeRC != null),\n        '`textureShape` must be defined when `texture` is defined');\n\n    this.size = util.sizeFromShape(shape);\n\n    if (data.values != null) {\n      util.assert(\n          this.size === data.values.length,\n          'Constructing ndarray of shape (' + this.size + ') should match the' +\n              ' length of values (' + data.values.length + ')');\n    }\n\n    this.shape = shape;\n    this.data = data;\n    const dim = this.shape.length;\n\n    if (dim < 2) {\n      this.strides = [];\n    } else {\n      // Last dimension has implicit stride of 1, thus having D-1 (instead of D)\n      // strides.\n      this.strides = new Array(dim - 1);\n      this.strides[dim - 2] = this.shape[dim - 1];\n      for (let i = dim - 3; i >= 0; --i) {\n        this.strides[i] = this.strides[i + 1] * this.shape[i + 1];\n      }\n    }\n  }\n\n  /** Creates a ndarray of zeros with the specified shape. */\n  static zeros<T extends NDArray>(shape: number[]): T {\n    const values = new Float32Array(util.sizeFromShape(shape));\n    return NDArray.make<T>(shape, {values});\n  }\n\n  /** Creates a ndarray of zeros with the same shape as the specified ndarray.\n   */\n  static zerosLike<T extends NDArray>(another: T): T {\n    return NDArray.zeros(another.shape) as T;\n  }\n\n  /** Creates a ndarray with the same values/shape as the specified ndarray. */\n  static like<T extends NDArray>(another: T): T {\n    const values = another.getValues();\n    return NDArray.make<T>(another.shape, {values: new Float32Array(values)});\n  }\n\n  /**\n   * Makes a new ndarray with the provided shape and values. Values should be in\n   * a flat array.\n   */\n  static make<T extends NDArray>(shape: number[], data: NDArrayData): T {\n    switch (shape.length) {\n      case 0:\n        return new Scalar(data) as T;\n      case 1:\n        // tslint:disable-next-line:no-any\n        return new Array1D(data) as any;\n      case 2:\n        // tslint:disable-next-line:no-any\n        return new Array2D(shape as [number, number], data) as any;\n      case 3:\n        // tslint:disable-next-line:no-any\n        return new Array3D(shape as [number, number, number], data) as any;\n      case 4:\n        return new Array4D(\n                   // tslint:disable-next-line:no-any\n                   shape as [number, number, number, number], data) as any;\n      default:\n        // tslint:disable-next-line:no-any\n        return new NDArray(shape, data) as any;\n    }\n  }\n\n  /** Reshapes the current ndarray into the provided shape. */\n  reshape<T extends NDArray>(newShape: number[]): T {\n    if (util.arraysEqual(this.shape, newShape)) {\n      // No-op.\n      // tslint:disable-next-line:no-any\n      return this as any;\n    }\n\n    util.assert(\n        this.size === util.sizeFromShape(newShape),\n        'new shape and old shape must have the same number of elements.');\n\n    return NDArray.make<T>(newShape, this.data);\n  }\n\n  asScalar(): Scalar {\n    util.assert(this.size === 1, 'The array must have only 1 element.');\n    return this.reshape<Scalar>([]);\n  }\n\n  as1D(): Array1D {\n    return this.reshape<Array1D>([this.size]);\n  }\n\n  as2D(rows: number, columns: number): Array2D {\n    return this.reshape<Array2D>([rows, columns]);\n  }\n\n  as3D(rows: number, columns: number, depth: number): Array3D {\n    return this.reshape<Array3D>([rows, columns, depth]);\n  }\n\n  as4D(rows: number, columns: number, depth: number, depth2: number): Array4D {\n    return this.reshape<Array4D>([rows, columns, depth, depth2]);\n  }\n\n  get rank(): number {\n    return this.shape.length;\n  }\n\n  get(...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return this.getValues()[index];\n  }\n\n  add(value: number, ...locs: number[]) {\n    this.set(this.get(...locs) + value, ...locs);\n  }\n\n  set(value: number, ...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    this.getValues()[index] = value;\n  }\n\n  locToIndex(locs: number[]): number {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return index;\n  }\n\n  indexToLoc(index: number): number[] {\n    const locs: number[] = new Array(this.shape.length);\n    for (let i = 0; i < locs.length - 1; ++i) {\n      locs[i] = Math.floor(index / this.strides[i]);\n      index -= locs[i] * this.strides[i];\n    }\n    locs[locs.length - 1] = index;\n    return locs;\n  }\n\n  fill(value: number) {\n    this.getValues().fill(value);\n  }\n\n  getData(): NDArrayData {\n    return this.data;\n  }\n\n  getValues(): Float32Array {\n    if (this.data.values == null) {\n      throwIfGPUNotInitialized();\n      this.data.values = GPGPU.downloadMatrixFromTexture(\n          this.data.texture!, this.data.textureShapeRC![0],\n          this.data.textureShapeRC![1]);\n      this.disposeTexture();\n    }\n    return this.data.values;\n  }\n\n  private uploadToGPU(preferredTexShape?: [number, number]) {\n    throwIfGPUNotInitialized();\n    this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(\n        GPGPU.gl, this.shape, preferredTexShape);\n    this.data.texture =\n        TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC);\n\n    GPGPU.uploadMatrixToTexture(\n        this.data.texture, this.data.textureShapeRC[0],\n        this.data.textureShapeRC[1], this.data.values!);\n\n    this.data.values = null!;\n  }\n\n  getTexture(preferredShapeRC?: [number, number]): WebGLTexture {\n    if (this.data.texture == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.texture!;\n  }\n\n  getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] {\n    if (this.data.textureShapeRC == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.textureShapeRC!;\n  }\n\n  dispose(): void {\n    this.data.values = null!;\n    this.shape = null!;\n    if (this.data.texture != null) {\n      this.disposeTexture();\n    }\n  }\n\n  private disposeTexture() {\n    throwIfGPUNotInitialized();\n    TEXTURE_MANAGER.releaseTexture(\n        this.data.texture!, this.data.textureShapeRC!);\n    this.data.texture = null!;\n    this.data.textureShapeRC = null!;\n  }\n\n  inGPU(): boolean {\n    return this.data.texture != null;\n  }\n\n  equals(t: NDArray): boolean {\n    return util.arraysEqual(this.shape, t.shape) &&\n        util.arraysEqual(this.getValues(), t.getValues());\n  }\n\n  static rand<T extends NDArray>(shape: number[], randFunction: () => number):\n      T {\n    const size = util.sizeFromShape(shape);\n    const values = new Float32Array(size);\n    for (let i = 0; i < size; i++) {\n      values[i] = randFunction();\n    }\n\n    return NDArray.make<T>(shape, {values});\n  }\n\n  static randNormal<T extends NDArray>(shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev));\n  }\n\n  static randTruncatedNormal<T extends NDArray>(\n      shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev, true));\n  }\n\n  static randUniform<T extends NDArray>(shape: number[], a: number, b: number) {\n    return NDArray.rand<T>(shape, () => util.randUniform(a, b));\n  }\n}\n\nexport class Scalar extends NDArray {\n  constructor(data: NDArrayData) {\n    if (data.texture != null) {\n      data.textureShapeRC = [1, 1];\n    }\n    super([], data);\n  }\n\n  static new(value: number) {\n    return new Scalar({values: new Float32Array([value])});\n  }\n\n  static ZERO = Scalar.new(0);\n  static ONE = Scalar.new(1);\n  static TWO = Scalar.new(2);\n  static NEG_ONE = Scalar.new(-1);\n\n  get(): number {\n    return this.getValues()[0];\n  }\n\n  set(value: number) {\n    this.getValues()[0] = value;\n  }\n\n  add(value: number) {\n    this.getValues()[0] += value;\n  }\n}\n\nexport class Array1D extends NDArray {\n  shape: [number];\n\n  constructor(data: NDArrayData) {\n    const shape = (data.values != null) ?\n        [data.values.length] :\n        [util.sizeFromShape(data.textureShapeRC!)];\n    super(shape, data);\n  }\n\n  static new(values: Float32Array|number[]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      util.assert(\n          inferredShape.length === 1,\n          `Error constructing Array1D. Shape of values ${inferredShape} is ` +\n              `not 1 dimensional.`);\n    }\n    return new Array1D({values: toTypedArray(values)});\n  }\n\n  get(i: number): number {\n    return this.getValues()[i];\n  }\n\n  set(value: number, i: number) {\n    this.getValues()[i] = value;\n  }\n\n  add(value: number, i: number) {\n    this.getValues()[i] += value;\n  }\n\n  locToIndex(loc: [number]): number {\n    return loc[0];\n  }\n\n  indexToLoc(index: number): [number] {\n    return [index];\n  }\n\n  static zeros(shape: [number]): Array1D {\n    return NDArray.zeros<Array1D>(shape);\n  }\n}\n\nexport class Array2D extends NDArray {\n  shape: [number, number];\n\n  private stride0: number;\n\n  constructor(shape: [number, number], data: NDArrayData) {\n    util.assert(shape.length === 2, 'Shape should be of length 2');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n  }\n\n  static new(\n      shape: [number, number], values: Float32Array|number[]|number[][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array2D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array2D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number) {\n    return this.getValues()[this.stride0 * i + j];\n  }\n\n  set(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] = value;\n  }\n\n  add(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] += value;\n  }\n\n  locToIndex(locs: [number, number]): number {\n    return this.stride0 * locs[0] + locs[1];\n  }\n\n  indexToLoc(index: number): [number, number] {\n    return [Math.floor(index / this.stride0), index % this.stride0];\n  }\n\n  static zeros(shape: [number, number]): Array2D {\n    return NDArray.zeros<Array2D>(shape);\n  }\n}\n\nexport class Array3D extends NDArray {\n  shape: [number, number, number];\n  private stride0: number;\n  private stride1: number;\n\n  constructor(shape: [number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 3, 'Shape should be of length 3');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n  }\n\n  static new(\n      shape: [number, number, number],\n      values: Float32Array|number[]|number[][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array3D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array3D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number) {\n    return this.getValues()[this.stride0 * i + this.stride1 * j + k];\n  }\n\n  set(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] += value;\n  }\n\n  locToIndex(locs: [number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2];\n  }\n\n  indexToLoc(index: number): [number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    return [i, Math.floor(index / this.stride1), index % this.stride1];\n  }\n\n  static zeros(shape: [number, number, number]): Array3D {\n    return NDArray.zeros<Array3D>(shape);\n  }\n}\n\nexport class Array4D extends NDArray {\n  shape: [number, number, number, number];\n  private stride0: number;\n  private stride1: number;\n  private stride2: number;\n\n  constructor(shape: [number, number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 4, 'Shape should be of length 4');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n    this.stride2 = this.strides[2];\n  }\n\n  static new(\n      shape: [number, number, number, number],\n      values: Float32Array|number[]|number[][][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array4D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array4D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number, l: number) {\n    return this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l];\n  }\n\n  set(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value;\n  }\n\n  locToIndex(locs: [number, number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] +\n        this.stride2 * locs[2] + locs[3];\n  }\n\n  indexToLoc(index: number): [number, number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    const j = Math.floor(index / this.stride1);\n    index -= j * this.stride1;\n    return [i, j, Math.floor(index / this.stride2), index % this.stride2];\n  }\n\n  static zeros(shape: [number, number, number, number]): Array4D {\n    return NDArray.zeros<Array4D>(shape);\n  }\n}\n\ntype ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][];\n\nfunction toTypedArray(a: ArrayData): Float32Array {\n  return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a));\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    uniform sampler2D matrixAScalar;\n    uniform sampler2D matrixBScalar;\n    varying vec2 resultUV;\n\n    const vec2 halfTexel = vec2(0.5, 0.5);\n\n    void main() {\n      float a = texture2D(matrixA, resultUV).r;\n      float b = texture2D(matrixB, resultUV).r;\n      float aScalar = texture2D(matrixAScalar, halfTexel).r;\n      float bScalar = texture2D(matrixBScalar, halfTexel).r;\n      vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n      gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n    }`;\n}\n\nexport function addScaledMatrices(\n    gpgpu: GPGPUContext, addScaledMatricesProgram: WebGLProgram,\n    a: WebGLTexture, b: WebGLTexture, rows: number, columns: number,\n    aScalar: WebGLTexture, bScalar: WebGLTexture, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(addScaledMatricesProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2);\n  gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3);\n  gpgpu.executeProgram();\n}\n\nexport function uploadAddScaledMatricesDownload(\n    a: Float32Array, b: Float32Array, rows: number, columns: number,\n    aScalar: number, bScalar: number): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource());\n\n  const aTex = gpgpu.createMatrixTexture(rows, columns);\n  const bTex = gpgpu.createMatrixTexture(rows, columns);\n  const aScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const bScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const resultTex = gpgpu.createMatrixTexture(rows, columns);\n\n  gpgpu.uploadMatrixToTexture(aTex, rows, columns, a);\n  gpgpu.uploadMatrixToTexture(bTex, rows, columns, b);\n  gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar]));\n  gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar]));\n\n  addScaledMatrices(\n      gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex,\n      resultTex);\n\n  const result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns);\n\n  gpgpu.deleteMatrixTexture(aTex);\n  gpgpu.deleteMatrixTexture(bTex);\n  gpgpu.deleteMatrixTexture(resultTex);\n  gpgpu.deleteMatrixTexture(aScalarTex);\n  gpgpu.deleteMatrixTexture(bScalarTex);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\n\nimport * as binaryop_gpu from './binaryop_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport type Operation = '+' | '-' | '*' | '/';\n\nexport enum OperandType {\n  MATRIX,\n  SCALAR\n}\n\nexport function getFragmentShaderSource(\n    aType: OperandType, aOrientation: MatrixOrientation, op: Operation,\n    bType: OperandType, bOrientation: MatrixOrientation): string {\n  const aUV = operandToShaderSnippet(aType, aOrientation);\n  const bUV = operandToShaderSnippet(bType, bOrientation);\n  const resultOp = `gl_FragColor = vec4(a ${op} b, 0, 0, 0);`;\n  return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp);\n}\n\nfunction operandToShaderSnippet(\n    operand: OperandType, orientation: MatrixOrientation): string {\n  switch (operand) {\n    case OperandType.MATRIX:\n      return 'resultUV' +\n          (orientation === MatrixOrientation.REGULAR ? '.st' : '.ts');\n    case OperandType.SCALAR:\n      return 'vec2(0.5, 0.5)';\n    default:\n      throw new Error('Unknown operand type');\n  }\n}\n\nexport function addSubMulDiv(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  return binaryop_gpu.binaryOp(\n      gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result,\n      resultShapeRowCol);\n}\n\nexport function uploadScalarPlusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '+', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixMinusScalarDownload(\n    a: Float32Array, aShape: [number, number], b: number,\n    aOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR,\n      MatrixOrientation.REGULAR);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      a, aShape, new Float32Array([b]), [1, 1], src);\n}\n\nexport function uploadScalarMinusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '-', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadScalarTimesMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '*', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixTimesMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n\nexport function uploadMatrixPlusMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as argminmax_gpu from './argminmax_gpu';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      float argMaxA = getArgMinMax(matrixA);\n      float argMaxB = getArgMinMax(matrixB);\n      float value;\n      if (isNaN(argMaxA)) {\n        value = argMaxA;\n      } else if (isNaN(argMaxB)) {\n        value = argMaxB;\n      } else {\n        value = float(argMaxA == argMaxB);\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getArgMaxEqualsFragmentShaderSource(\n    rows: number, columns: number): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function argMaxEquals(\n    gpgpu: GPGPUContext, maxEqualsProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, numRows: number, numCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(maxEqualsProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n    }`;\n}\n\nfunction getArgMinMaxFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    getFragmentShaderGetArgMinMaxSource(compOp, rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function getArgMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '<');\n}\n\nexport function getArgMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '>');\n}\n\nexport function getFragmentShaderGetArgMinMaxSource(\n    compOp: string, rows: number, columns: number) {\n  return `\n    const vec2 dimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    float getArgMinMax(in sampler2D matrix) {\n      vec2 bestCR = vec2(0, 0);\n      float bestValue = texture2D(matrix, bestCR).r;\n\n      for (float c = 0.0; c < dimCR.x; c += 1.0) {\n        for (float r = 0.0; r < dimCR.y; r += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / dimCR;\n          float value = texture2D(matrix, uv).r;\n          if (isNaN(value)) {\n            return value;\n          }\n          if (value ${compOp} bestValue) {\n            bestValue = value;\n            bestCR = cr;\n          }\n        }\n      }\n      return bestCR.x + (bestCR.y * dimCR.x);\n    }\n  `;\n}\n\nexport function argMinMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderAvgPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'avg', false);\n}\n\nexport function avgPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    xTexShapeRC: [number, number], meanTexShapeRC: [number, number],\n    varianceTexShapeRC: [number, number],\n    offsetTexShapeRC: [number, number]|null,\n    scaleTexShapeRC?: [number, number]|null, varianceEpsilon = 0.001): string {\n  let offsetSamplerSnippet = '';\n  let offsetShapeInitializationSnippet = '';\n  let offsetCoordsSnippet = '';\n  let offsetUVSnippet = '';\n  let offsetValueSnippet = '';\n  let offsetOperationSnippet = '0.0';\n\n  let scaleSamplerSnippet = '';\n  let scaleShapeInitializationSnippet = '';\n  let scaleCoordsSnippet = '';\n  let scaleUVSnippet = '';\n  let scaleValueSnippet = '';\n  let scaleOperationSnippet = '';\n\n  if (offsetTexShapeRC != null) {\n    offsetSamplerSnippet = 'uniform sampler2D offset;';\n    offsetShapeInitializationSnippet = `const vec2 offsetShapeCR = vec2(\n            ${offsetTexShapeRC[1]}, ${offsetTexShapeRC[0]});`;\n    offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);';\n    offsetUVSnippet =\n        'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;';\n    offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;';\n    offsetOperationSnippet = 'offsetValue';\n  }\n\n  if (scaleTexShapeRC != null) {\n    scaleSamplerSnippet = 'uniform sampler2D scale;';\n    scaleShapeInitializationSnippet = `const vec2 scaleShapeCR = vec2(\n            ${scaleTexShapeRC[1]}, ${scaleTexShapeRC[0]});`;\n    scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);';\n    scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;';\n    scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;';\n    scaleOperationSnippet = 'inv *= scaleValue;';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D mean;\n    uniform sampler2D variance;\n    ${offsetSamplerSnippet}\n    ${scaleSamplerSnippet}\n\n    varying vec2 resultUV;\n\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 meanShapeCR = vec2(${meanTexShapeRC[1]}, ${meanTexShapeRC[0]});\n    const vec2 varianceShapeCR = vec2(\n        ${varianceTexShapeRC[1]}, ${varianceTexShapeRC[0]});\n\n    ${offsetShapeInitializationSnippet}\n    ${scaleShapeInitializationSnippet}\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const float varianceEpsilon = ${varianceEpsilon};\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n      vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n      ${offsetCoordsSnippet}\n      ${scaleCoordsSnippet}\n\n      vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n      vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n      ${offsetUVSnippet}\n      ${scaleUVSnippet}\n\n      float xValue = texture2D(x, resultUV).r;\n      float meanValue = texture2D(mean, meanUV).r;\n      float varianceValue = texture2D(variance, varianceUV).r;\n      ${offsetValueSnippet}\n      ${scaleValueSnippet}\n\n      float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n      ${scaleOperationSnippet}\n      float xTimesInv = xValue * inv;\n      float meanTimesInvWithOffset = ${offsetOperationSnippet}\n          - meanValue * inv;\n\n      gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n    }`;\n}\n\nexport function batchNormalization(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    xShapeRowCol: [number, number], mean: WebGLTexture,\n    meanShapeRowCol: [number, number], variance: WebGLTexture,\n    varianceShapeRowCol: [number, number], offset: WebGLTexture|null,\n    offsetShapeRowCol: [number, number]|null, scale: WebGLTexture|null,\n    scaleShapeRowCol: [number, number]|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.setInputMatrixTexture(mean, 'mean', 1);\n  gpgpu.setInputMatrixTexture(variance, 'variance', 2);\n  let nextIndex = 3;\n  if (offset != null) {\n    gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex);\n    nextIndex++;\n  }\n  if (scale != null) {\n    gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    aResultUV: string, bResultUV: string, op: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;\n\n    void main() {\n      float a = texture2D(matrixA, ${aResultUV}).r;\n      float b = texture2D(matrixB, ${bResultUV}).r;\n      ${op}\n    }`;\n}\n\nexport function binaryOp(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n\nexport function uploadBinaryOpDownload(\n    a: Float32Array, aShape: [number, number], b: Float32Array,\n    bShape: [number, number], fragmentShaderSource: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(fragmentShaderSource);\n\n  const aTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(aShape[0], aShape[1]);\n  const bTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(bShape[0], bShape[1]);\n\n  const resultShape: [number, number] =\n      [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])];\n\n  const resultTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(resultShape[0], resultShape[1]);\n\n  gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a);\n  gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b);\n\n  binaryOp(\n      gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture,\n      resultShape);\n  const result = gpgpu.downloadMatrixFromTexture(\n      resultTexture, resultShape[0], resultShape[1]);\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    x1ShapeRCD: [number, number, number], x2ShapeRCD: [number, number, number],\n    resultShapeRCD: [number, number, number], axis: number): string {\n  const x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD);\n  const x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD);\n\n  const yAxes = ['yR', 'yC', 'yD'];\n  const concatAxis = yAxes[axis];\n\n  return `\n    precision highp float;\n    uniform sampler2D x1;\n    uniform sampler2D x2;\n\n    const vec2 x1ShapeCR = vec2(${x1TexShapeRC[1]}, ${x1TexShapeRC[0]});\n    const vec2 x2ShapeCR = vec2(${x2TexShapeRC[1]}.0, ${x2TexShapeRC[0]}.0);\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${resultShapeRCD[2]}.0);\n      float yD = mod(yTexCR.x, ${resultShapeRCD[2]}.0);\n\n      float value = 0.0;\n\n      if (${concatAxis} < ${x1ShapeRCD[axis]}.0) {\n        // Map yR, yC, yD back to x1 coordinates.\n        vec2 x1CR = vec2(yC * ${x1ShapeRCD[2]}.0 + yD, yR);\n        vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n        value = texture2D(x1, x1UV).r;\n      } else {\n        ${concatAxis} = ${concatAxis} - ${x1ShapeRCD[axis]}.0;\n\n        // Map yR, yC, yD back to x2 coordinates.\n        vec2 x2CR = vec2(yC * ${x2ShapeRCD[2]}.0 + yD, yR);\n        vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n        value = texture2D(x2, x2UV).r;\n      }\n\n      gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function concat3D(\n    gpgpu: GPGPUContext, program: WebGLProgram, x1: WebGLTexture,\n    x2: WebGLTexture, result: WebGLTexture, resultShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x1, 'x1', 0);\n  gpgpu.setInputMatrixTexture(x2, 'x2', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport * as conv_gpu from './conv_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderDerWeightsSource(\n    xShapeRowColDepth: [number, number, number], fSize: number,\n    outputDepth: number, stride: number, zeroPad: number) {\n  const getMatrixValueOrZeroPad =\n      conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const inputDepth = xShapeRowColDepth[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth);\n\n  const yShape = conv_util.computeOutputShape3D(\n      xShapeRowColDepth, fSize, outputDepth, stride, zeroPad);\n  const yNumRows = yShape[0];\n  const yNumCols = yShape[1];\n  const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape);\n\n  const fSizeTimesInputDepth = fSize * inputDepth;\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D dy;\n  `;\n\n  return prologue + '\\n' + getMatrixValueOrZeroPad + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]});\n\n    void main() {\n      vec2 wTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n      float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0);\n      float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0;\n      float wC = floor(wTexRLeftover / ${inputDepth}.0);\n      float d1 = mod(wTexRLeftover, ${inputDepth}.0);\n      float d2 = wTexCR.x;\n\n      // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float xR = wR + yR * ${stride}.0 - ${zeroPad}.0;\n        float xTexR = xR;\n        float yTexR = yR;\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          float xC = wC + yC * ${stride}.0 - ${zeroPad}.0;\n\n          // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) +\n                        vec2(d1, d2);\n          float xTexC = xyTexC.x;\n          float yTexC = xyTexC.y;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read x(xR, xC, d1) (potentially zero-padded).\n          float xValue =\n            getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n          dotProd += (xValue * dyValue);\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderConvTransposeSource(\n    xShapeRCD: [number, number, number], fSize: number, origInputDepth: number,\n    origStride: number, origPad: number, hasBias: boolean) {\n  const pad = fSize - 1 - origPad;\n  const [xRows, xCols, origOutputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize);\n\n  const getBiasValue = hasBias ?\n      conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) :\n      '';\n  const biasPrologue = hasBias ? 'uniform sampler2D biases;' : '';\n  const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : '';\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    ${biasPrologue}\n    `;\n\n  return prologue + '\\n' + getBiasValue + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${origInputDepth}.0);\n      float d2 = mod(yTexCR.x, ${origInputDepth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float xR = (xRCorner + wR) / ${origStride}.0;\n        // TODO(smilkov): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) {\n          continue;\n        }\n\n        float wRPerm = ${fSize}.0 - 1.0 - wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float xC = (xCCorner + wC) / ${origStride}.0;\n          if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) {\n            continue;\n          }\n\n          float wCPerm = ${fSize}.0 - 1.0 - wC;\n          float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 +\n                        wCPerm * ${origInputDepth}.0 + d2;\n\n          for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${origOutputDepth}.0 + d1;\n            float wTexC = d1;\n\n            // Read x(xR, xC, d1).\n            vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n            float xValue = texture2D(x, xUV).r;\n\n            // Read w(wRPerm, wCPerm, d2, d1).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      ${biasOperation}\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderDerBiasSource(\n    dyShapeRCD: [number, number, number]) {\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const [yNumRows, yNumCols, outputDepth] = dyShapeRCD;\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n      // The bias texture RC shape is [1, d2].\n      float d2 = biasTexCR.x;\n\n      float derBias = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float yTexR = yR;\n\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          float yTexC = yC * ${outputDepth}.0 + d2;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          derBias += dyValue;\n        }\n      }\n      gl_FragColor = vec4(derBias, 0, 0, 0);\n    }`;\n}\n\nexport function derBias(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    result: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.executeProgram();\n}\n\nexport function derWeights(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    dyTex: WebGLTexture, result: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 1);\n  gpgpu.executeProgram();\n}\n\nexport function convTranspose(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    weightsTex: WebGLTexture, biasesTex: WebGLTexture|null,\n    resultTex: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1);\n  if (biasesTex != null) {\n    gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    uniform sampler2D biases;\n    varying vec2 resultUV;`;\n}\n\nexport function getFragmentShaderGetMatrixValueOrZeroPadSource(): string {\n  return `\n    float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n        vec2 requestedCR) {\n      vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n      float value = texture2D(matrix, uv).r;\n      bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n      bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n      bool outside = lessThanZero || greaterThanOne;\n      return mix(value, 0.0, float(outside));\n    }`;\n}\n\nexport function getFragmentShaderConvolveSource(\n    xShapeRCD: [number, number, number], fSize: number, outputDepth: number,\n    stride: number, pad: number, hasBias: boolean) {\n  const [xRows, xCols, inputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n\n  return `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${outputDepth}.0);\n      float d2 = mod(yTexCR.x, ${outputDepth}.0);\n      float wTexC = d2;\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n\n          for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${inputDepth}.0 + d1;\n            float wTexR = wR * ${fSize * inputDepth}.0 +\n                wC * ${inputDepth}.0 + d1;\n\n            float xValue =\n                getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n            // Read w(wR, wC, d1, d2).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      if (${hasBias}) {\n        dotProd += getBiasValue(biases, d2);\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderGetBiasValueSource(outputDepth: number):\n    string {\n  return `\n    float getBiasValue(in sampler2D bias, float biasC) {\n      const vec2 biasShapeCR = vec2(${outputDepth}, 1);\n      vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0);\n      vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n      return texture2D(bias, biasUV).r;\n    }`;\n}\n\nexport function getFragmentShaderSource(\n    aShapeRowColDepth: [number, number, number], resultDepth: number,\n    fieldSize: number, stride: number, zeroPad: number,\n    hasBias: boolean): string {\n  const aShapeRC: [number, number] =\n      conv_util.computeTexShapeFrom3D(aShapeRowColDepth);\n\n  const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape(\n      aShapeRowColDepth[2], resultDepth, fieldSize);\n\n  const prologue = getFragmentShaderPrologueSource();\n  const getMatrixValueOrZeroPad =\n      getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const convolve = getFragmentShaderConvolveSource(\n      aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias);\n  const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth);\n\n  return [\n    prologue,\n    getMatrixValueOrZeroPad,\n    getBiasValue,\n    convolve,\n  ].join('\\n');\n}\n\nexport function convolve(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'x', 0);\n  gpgpu.setInputMatrixTexture(weights, 'weights', 1);\n  if (biases != null) {\n    gpgpu.setInputMatrixTexture(biases, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  return `\n    precision highp float;\n    uniform sampler2D source;\n    uniform vec2 sourceStartCR;\n    uniform vec2 destStartCR;\n\n    const vec2 sourceShapeCR =\n      vec2(${sourceShapeRowCol[1]}, ${sourceShapeRowCol[0]});\n    const vec2 sourceSizeCR =\n      vec2(${sourceSizeRowCol[1]}, ${sourceSizeRowCol[0]});\n    const vec2 destSizeCR =\n      vec2(${destSizeRowCol[1]}, ${destSizeRowCol[0]});\n\n    void main() {\n      vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n      float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n      vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n        floor(destOffsetFlat / sourceSizeCR.x));\n      vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n      vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n      gl_FragColor = texture2D(source, sourceUV);\n    }`;\n}\n\nexport function copy(\n    gpgpu: GPGPUContext, program: WebGLProgram, source: WebGLTexture,\n    sourceShapeRowCol: [number, number], sourceStartRowCol: [number, number],\n    sourceSizeRowCol: [number, number], dest: WebGLTexture,\n    destShapeRowCol: [number, number], destStartRowCol: [number, number],\n    destSizeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]);\n  gpgpu.setOutputMatrixWriteRegion(\n      destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1],\n      destSizeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(source, 'source', 0);\n  const sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR');\n  gpgpu.gl.uniform2f(\n      sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]);\n  const destStartCRLoc = gpgpu.getUniformLocation('destStartCR');\n  gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getExpUnaryOp(): string {\n  return 'gl_FragColor = vec4(exp(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp());\n}\n\nexport function exp(\n    gpgpu: GPGPUContext, expProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result);\n}\n\nexport function uploadExpDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from './gpgpu_util';\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nimport {WebGLLoseContextExtension} from './webgl_util';\n\nexport class GPGPUContext {\n  gl: WebGLRenderingContext;\n  textureFloatExtension: {};\n  colorBufferFloatExtension: {};\n  loseContextExtension: WebGLLoseContextExtension;\n  vertexBuffer: WebGLBuffer;\n  indexBuffer: WebGLBuffer;\n  framebuffer: WebGLFramebuffer;\n  outputTexture: WebGLTexture|null = null;\n  program: WebGLProgram|null = null;\n  private disposed = false;\n  private autoDebugValidate = false;\n\n  constructor(gl?: WebGLRenderingContext) {\n    if (gl != null) {\n      this.gl = gl;\n    } else {\n      this.gl = gpgpu_util.createWebGLContext();\n    }\n\n    // WebGL 2.0 enables texture floats without an extension.\n    if (!webgl_util.isWebGL2Enabled()) {\n      this.textureFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float');\n    } else {\n      this.colorBufferFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float');\n    }\n\n    this.loseContextExtension =\n        webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as\n        WebGLLoseContextExtension;\n    this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl);\n    this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl);\n    this.framebuffer = webgl_util.createFramebuffer(this.gl);\n  }\n\n  public dispose() {\n    this.throwIfDisposed();\n    if (this.program != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound WebGLProgram.' +\n          ' This is probably a resource leak, delete the program with ' +\n          'GPGPUContext.deleteProgram before disposing.');\n    }\n    if (this.outputTexture != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound output matrix ' +\n          'texture.  This is probably a resource leak, delete the output ' +\n          'matrix texture with GPGPUContext.deleteMatrixTexture before ' +\n          'disposing.');\n    }\n    const gl = this.gl;\n    webgl_util.callAndCheck(gl, () => gl.finish());\n    webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer));\n    webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer));\n    webgl_util.callAndCheck(\n        gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer));\n    this.loseContextExtension.loseContext();\n    this.disposed = true;\n  }\n\n  public enableAutomaticDebugValidation(enabled: boolean) {\n    this.autoDebugValidate = enabled;\n    webgl_util.enableDebugWebGLErrorChecking(enabled);\n  }\n\n  public createMatrixTexture(rows: number, columns: number): WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createMatrixTexture(this.gl, rows, columns);\n  }\n\n  public uploadPixelDataToTexture(\n      texture: WebGLTexture,\n      pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n    this.throwIfDisposed();\n    gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels);\n  }\n\n  public createPackedMatrixTexture(rows: number, columns: number):\n      WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns);\n  }\n\n  public deleteMatrixTexture(texture: WebGLTexture) {\n    this.throwIfDisposed();\n    if (this.outputTexture === texture) {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n      this.outputTexture = null;\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture));\n  }\n\n  public uploadMatrixToTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    const numChannels = 1;\n    return gpgpu_util.uploadMatrixToTexture(\n        this.gl, texture, rows, columns, matrix, numChannels);\n  }\n\n  public uploadMatrixToPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    return gpgpu_util.uploadMatrixToPackedTexture(\n        this.gl, texture, rows, columns, matrix);\n  }\n\n  public downloadMatrixFromTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () =>\n            gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns));\n  }\n\n  public downloadMatrixFromPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () => gpgpu_util.downloadMatrixFromPackedOutputTexture(\n            this.gl, rows, columns));\n  }\n\n  public createProgram(fragmentShaderSource: string): WebGLProgram {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    const fragmentShader: WebGLShader =\n        webgl_util.createFragmentShader(gl, fragmentShaderSource);\n    const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl);\n    const program: WebGLProgram = webgl_util.createProgram(gl);\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader));\n    webgl_util.linkProgram(gl, program);\n    if (this.autoDebugValidate) {\n      webgl_util.validateProgram(gl, program);\n    }\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader));\n    return program;\n  }\n\n  public deleteProgram(program: WebGLProgram) {\n    this.throwIfDisposed();\n    if (program === this.program) {\n      this.program = null;\n    }\n    if (program != null) {\n      webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program));\n    }\n  }\n\n  public setProgram(program: WebGLProgram|null) {\n    this.throwIfDisposed();\n    this.program = program;\n    if ((this.program != null) && this.autoDebugValidate) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program));\n  }\n\n  public getUniformLocation(uniformName: string): WebGLUniformLocation {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    return webgl_util.getProgramUniformLocationOrThrow(\n        this.gl, this.program!, uniformName);\n  }\n\n  public setInputMatrixTexture(\n      inputMatrixTexture: WebGLTexture, uniformName: string,\n      textureUnit: number) {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    webgl_util.bindTextureToProgramUniformSampler(\n        this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit);\n  }\n\n  public setOutputMatrixTexture(\n      outputMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows);\n  }\n\n  public setOutputPackedMatrixTexture(\n      outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.throwIfDisposed();\n    const [width, height] =\n        tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n    this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height);\n  }\n\n  public setOutputMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    this.setOutputMatrixWriteRegionDriver(\n        startColumn, startRow, numColumns, numRows);\n  }\n\n  public setOutputPackedMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    throw new Error('setOutputPackedMatrixWriteRegion not implemented.');\n  }\n\n  public debugValidate() {\n    if (this.program != null) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.validateFramebuffer(this.gl);\n  }\n\n  public executeProgram() {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    const gl = this.gl;\n    gpgpu_util.bindVertexProgramAttributeStreams(\n        gl, this.program!, this.vertexBuffer);\n    if (this.autoDebugValidate) {\n      this.debugValidate();\n    }\n    webgl_util.callAndCheck(\n        gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0));\n  }\n\n  public blockUntilAllProgramsCompleted() {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(this.gl, () => this.gl.finish());\n  }\n\n  private downloadMatrixDriver(\n      texture: WebGLTexture,\n      downloadAndDecode: () => Float32Array): Float32Array {\n    this.throwIfDisposed();\n    webgl_util.bindColorTextureToFramebuffer(\n        this.gl, texture, this.framebuffer);\n    const result = downloadAndDecode();\n    if (this.outputTexture != null) {\n      webgl_util.bindColorTextureToFramebuffer(\n          this.gl, this.outputTexture, this.framebuffer);\n      if (this.autoDebugValidate) {\n        webgl_util.validateFramebuffer(this.gl);\n      }\n    } else {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n    }\n    return result;\n  }\n\n  private setOutputMatrixTextureDriver(\n      outputMatrixTextureMaybePacked: WebGLTexture, width: number,\n      height: number) {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    webgl_util.bindColorTextureToFramebuffer(\n        gl, outputMatrixTextureMaybePacked, this.framebuffer);\n    if (this.autoDebugValidate) {\n      webgl_util.validateFramebuffer(gl);\n    }\n    this.outputTexture = outputMatrixTextureMaybePacked;\n    webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height));\n    webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height));\n  }\n\n  private setOutputMatrixWriteRegionDriver(\n      x: number, y: number, width: number, height: number) {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(\n        this.gl, () => this.gl.scissor(x, y, width, height));\n  }\n\n  private throwIfDisposed() {\n    if (this.disposed) {\n      throw new Error('Attempted to use disposed GPGPUContext.');\n    }\n  }\n\n  private throwIfNoProgram() {\n    if (this.program == null) {\n      throw new Error('No GPU program is currently set.');\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nexport function getWebGLContextAttributes(): WebGLContextAttributes {\n  return {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: true\n  };\n}\n\nexport function createWebGLContext(canvas?: HTMLCanvasElement) {\n  const attributes = getWebGLContextAttributes();\n  let gl: WebGLRenderingContext;\n  if (canvas != null) {\n    gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes);\n  } else {\n    gl = webgl_util.createWebGLRenderingContext(attributes);\n  }\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE));\n  webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK));\n  return gl;\n}\n\nexport function createVertexShader(gl: WebGLRenderingContext): WebGLShader {\n  const vertexShaderSource = `\n    precision highp float;\n    attribute vec3 clipSpacePos;\n    attribute vec2 uv;\n    varying vec2 resultUV;\n\n    void main() {\n      gl_Position = vec4(clipSpacePos, 1);\n      resultUV = uv;\n    }`;\n  return webgl_util.createVertexShader(gl, vertexShaderSource);\n}\n\nexport function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // [x y z u v] * [upper-left, lower-left, upper-right, lower-right]\n  const vertexArray = new Float32Array(\n      [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]);\n  return webgl_util.createStaticVertexBuffer(gl, vertexArray);\n}\n\nexport function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // OpenGL (and WebGL) have \"CCW == front\" winding\n  const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]);\n  return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices);\n}\n\nfunction getTextureInternalFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled()) {\n    if (numChannels === 4) {\n      // tslint:disable-next-line:no-any\n      return (gl as any).RGBA32F;\n    }\n    // tslint:disable-next-line:no-any\n    return (gl as any).R32F;\n  }\n  return gl.RGBA;\n}\n\nfunction getTextureFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled() && numChannels === 1) {\n    // tslint:disable-next-line:no-any\n    return (gl as any).RED;\n  }\n  return gl.RGBA;\n}\n\nfunction createAndConfigureTexture(\n    gl: WebGLRenderingContext, width: number, height: number,\n    numChannels: number): WebGLTexture {\n  webgl_util.validateTextureSize(gl, width, height);\n  const texture = webgl_util.createTexture(gl);\n\n  const tex2d = gl.TEXTURE_2D;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  const format = getTextureFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n  return texture;\n}\n\nexport function createMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 1;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createColorMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createPackedMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function bindVertexProgramAttributeStreams(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    vertexBuffer: WebGLBuffer) {\n  const posOffset = 0;               // x is the first buffer element\n  const uvOffset = 3 * 4;            // uv comes after [x y z]\n  const stride = (3 * 4) + (2 * 4);  // xyz + uv, each entry is 4-byte float.\n  webgl_util.callAndCheck(\n      gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer));\n  webgl_util.bindVertexBufferToProgramAttribute(\n      gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset);\n  try {\n    webgl_util.bindVertexBufferToProgramAttribute(\n        gl, program, 'uv', vertexBuffer, 2, stride, uvOffset);\n  } catch (e) {\n    // Programs with 1x1 output textures don't use the uv attribute.\n    // This can cause the shader linker to dead-strip it, so we shouldn't\n    // complain or fail if it's not present.\n    if (!e.hasOwnProperty('namedVertexAttributeNotFound')) {\n      throw e;\n    }\n  }\n}\n\nexport function uploadPixelDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n  const numChannels = 4;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nfunction uploadDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, width: number,\n    height: number, data: Float32Array, numChannels: number) {\n  const textureFormat = getTextureFormat(gl, numChannels);\n\n  webgl_util.validateTextureSize(gl, width, height);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texSubImage2D(\n          gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT,\n          data));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function uploadMatrixToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array, numChannels: number) {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture =\n      numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n\n  uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels);\n}\n\nexport function uploadMatrixToPackedTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array) {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA);\n  const numChannels = 4;\n  uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels);\n}\n\nexport function downloadMatrixFromOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture = 4;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          rows * columns, channelsPerTexture));\n  const textureFormat = getTextureFormat(gl, channelsPerTexture);\n\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray));\n\n  const matrix = new Float32Array(rows * columns);\n  tex_util.decodeMatrixFromUnpackedArray(\n      unpackedArray, matrix, channelsPerTexture);\n  return matrix;\n}\n\nexport function downloadMatrixFromPackedOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA));\n  const matrix = new Float32Array(rows * columns);\n  return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getLogUnaryOp(): string {\n  return 'gl_FragColor = vec4(log(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp());\n}\n\nexport function log(\n    gpgpu: GPGPUContext, logProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result);\n}\n\nexport function uploadLogDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          aMax = max(aMax, aCur);\n        }\n      }\n\n      float expSum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          expSum += exp(aCur - aMax);\n        }\n      }\n\n      gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n    }`;\n}\n\nexport function logSumExp(\n    gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(logSumExpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadLogSumExpDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result[0];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderMaxPoolBackprop(\n    dyShapeRCD: [number, number, number], fSize: number, origStride: number,\n    origPad: number) {\n  const origInputDepth = dyShapeRCD[2];\n  const pad = fSize - 1 - origPad;\n  const [dyRows, dyCols, depth] = dyShapeRCD;\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n    uniform sampler2D maxPos;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n      float dxR = dxTexCR.y;\n      float dxC = floor(dxTexCR.x / ${origInputDepth}.0);\n      float d = mod(dxTexCR.x, ${origInputDepth}.0);\n\n      vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0);\n      float dyRCorner = dyRCCorner.x;\n      float dyCCorner = dyRCCorner.y;\n\n      // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float dyR = (dyRCorner + wR) / ${origStride}.0;\n        // TODO(nsthorat): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) {\n          continue;\n        }\n\n        float dyTexR = dyR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float dyC = (dyCCorner + wC) / ${origStride}.0;\n          if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) {\n            continue;\n          }\n\n          float dyTexC = dyC * ${depth}.0 + d;\n\n          // Read dy(dyR, dyC, d).\n          vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read maxPos(dyR, dyC, d).\n          float maxPosValue =\n              ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r;\n\n          // Get the current value, check it against the value from the\n          // position matrix.\n          float curPosValue = wR * ${fSize}.0 + wC;\n          float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n          dotProd += dyValue * mask;\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function maxPoolBackprop(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    maxPositionsTex: WebGLTexture, resultTex: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMaxPoolPositionsSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, true);\n}\n\nexport function getFragmentShaderMaxPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, false);\n}\n\nfunction getFragmentShaderMaxPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, computeMaxPositions: boolean) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions);\n}\n\nexport function maxPoolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMinPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'min', false);\n}\n\nexport function minPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 outputColumnRow;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      float value = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / aDimCR;\n          float candidate = texture2D(matrixA, uv).r;\n          if (isNaN(candidate)) {\n            gl_FragColor = vec4(candidate, 0, 0, 0);\n            return;\n          }\n          value = ${compOp}(value, candidate);\n        }\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'min');\n}\n\nexport function getMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'max');\n}\n\nexport function minMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\nimport {Array2D} from '../ndarray';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as shader_compiler from './shader_compiler';\n\nexport function getFragmentShader(\n    a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  const sharedDim =\n      (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]);\n  const aSnippet =\n      (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow';\n  const bSnippet =\n      (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i';\n\n  const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}];\n  const userCode = `\n    const float sharedDim = ${sharedDim}.0;\n\n    float dotARowBCol(float aRow, float bCol) {\n      float result = 0.0;\n      for (float i = 0.0; i < sharedDim; i += 1.0) {\n        float a = getMatrixA(${aSnippet});\n        float b = getMatrixB(${bSnippet});\n        result += (a * b);\n      }\n      return result;\n    }\n\n    void main() {\n      vec2 resRC = getOutputCoords();\n      setOutput(dotARowBCol(resRC.x, resRC.y));\n    }\n  `;\n  return shader_compiler.makeShader(inputs, out, userCode);\n}\n\nexport function multiplyMatrix(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getNegUnaryOp(): string {\n  return 'gl_FragColor = vec4(-value, 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp());\n}\n\nexport function neg(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, rows: number,\n    columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result);\n}\n\nexport function uploadNegDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) {\n  if (poolType === 'avg' && computePositions) {\n    throw new Error('Cannot compute positions for average pool.');\n  }\n\n  const depth = xShapeRCD[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n\n  let returnValue = 'minMaxValue';\n  if (computePositions) {\n    returnValue = 'minMaxPosition';\n  } else if (poolType === 'avg') {\n    returnValue = 'avgValue';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    varying vec2 resultUV;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${depth}.0);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // max/min x(?, ?, d) to get y(yR, yC, d).\n      // ? = to be determined\n      float minMaxValue = 0.0;\n      float minMaxValueFound = 0.0;\n      float minMaxPosition = 0.0;\n      float avgValue = 0.0;\n\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n          float xTexC = xC * ${depth}.0 + d;\n\n          vec2 texCR = vec2(xTexC, xTexR);\n\n          // Check if the requested UV is invalid.\n          vec2 uv = (texCR + halfCR) / xShapeCR;\n          bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n          bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n          bool outside = lessThanZero || greaterThanOne;\n          if (outside) {\n            continue;\n          }\n\n          float value = texture2D(x, uv).r;\n          if (isNaN(value)) {\n            gl_FragColor = vec4(value, 0, 0, 0);\n            return;\n          }\n          if (${poolType === 'avg'}) {\n            avgValue += value / ${fSize * fSize}.0;\n          } else {\n            // If a min / max value has already been found, use it. If not, use\n            // the current value.\n            float currentMinMaxValue = mix(\n                value, minMaxValue, minMaxValueFound);\n            if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) {\n              minMaxValue = value;\n              minMaxValueFound = 1.0;\n              if (${computePositions}) {\n                minMaxPosition = wR * ${fSize}.0 + wC;\n              }\n            }\n          }\n        }\n      }\n      gl_FragColor = vec4(${returnValue}, 0, 0, 0);\n    }`;\n}\n\nexport function poolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float sum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          sum += texture2D(matrixA, uv).r;\n        }\n      }\n      gl_FragColor = vec4(sum, 0, 0, 0);\n    }`;\n}\n\nexport function reduceSum(\n    gpgpu: GPGPUContext, reduceSumProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(reduceSumProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadReduceSumDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0];\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getReluUnaryOp(): string {\n  return `\n    float result = (value < 0.0 ? 0.0 : value);\n    gl_FragColor = vec4(result, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp());\n}\n\nexport function relu(\n    gpgpu: GPGPUContext, reluProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result);\n}\n\nexport function uploadReluDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nimport * as webgl_util from './webgl_util';\n\nexport function getRenderRGBShader(\n    gpgpu: GPGPUContext, destinationWidth: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    const float destinationWidth = ${destinationWidth}.0;\n    const float a = 1.0;\n\n    void main() {\n      float xr = floor(resultUV.s * destinationWidth) * 3.0;\n      vec3 x = xr + vec3(0, 1, 2);\n\n      float sourceWidth = destinationWidth * 3.0;\n      vec3 u = (x + 0.5) / sourceWidth;\n      float v = 1.0 - resultUV.t;\n\n      float r = texture2D(source, vec2(u[0], v)).r;\n      float g = texture2D(source, vec2(u[1], v)).r;\n      float b = texture2D(source, vec2(u[2], v)).r;\n\n      gl_FragColor = vec4(r, g, b, a);\n    }`;\n\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function renderToCanvas(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  renderToFramebuffer(gpgpu, renderShader, sourceTex);\n}\n\nexport function renderToFramebuffer(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  gpgpu.setProgram(renderShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform vec2 inputDimCR;\n    uniform vec2 resultDimCR;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 resultCR = floor(resultUV * resultDimCR);\n      // indexInFlat = row * stride + column, where stride == numOutputColumns\n      float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n      vec2 inputCR = vec2(\n        mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n        floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n      ) + halfCR;\n\n      vec2 inputUV = inputCR / inputDimCR;\n      gl_FragColor = texture2D(matrixA, inputUV);\n    }`;\n}\n\nexport function reshape(\n    gpgpu: GPGPUContext, reshapeProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture,\n    resultNumRows: number, resultNumCols: number) {\n  const inputSize = aNumRows * aNumCols;\n  const outputSize = resultNumCols * resultNumRows;\n  util.assert(\n      inputSize === outputSize,\n      `The input size (${inputSize}) and output size (${outputSize}) ` +\n          `must match`);\n\n  gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols);\n  gpgpu.setProgram(reshapeProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n\n  const inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR');\n  gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows);\n\n  const resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR');\n  gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows);\n\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as webgl_util from './webgl_util';\n\nexport function getFragmentShaderSource(\n    inputShapeRCD: [number, number, number],\n    outputDimensionsRowCol: [number, number], alignCorners: boolean): string {\n  const depth = inputShapeRCD[2];\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n\n  const effectiveInputShapeRCD = alignCorners ?\n      [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] :\n      inputShapeRCD;\n\n  const effectiveOutputShapeRCD = alignCorners ?\n      [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] :\n      [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth];\n\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    const vec2 inputShapeCR = vec2(${inputShapeRCD[1]}, ${inputShapeRCD[0]});\n    const vec2 inputShapeTexCR = vec2(\n        ${inputTexShapeRC[1]}, ${inputTexShapeRC[0]});\n\n    const vec2 effectiveInputOverOutputRatioCR = vec2(\n        ${effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1]},\n        ${effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0]});\n\n    float sampleInput(float col, float row, float d) {\n      vec2 uv = (vec2(col * ${depth}.0 + d, row) + halfCR) / inputShapeTexCR;\n      return texture2D(matrixA, uv).r;\n    }\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n      vec2 yCR = vec2(floor(yTexCR.x / ${depth}.0), yTexCR.y);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      // Fractional source index.\n      vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n      // Compute the four integer indices.\n      vec2 sourceFloorCR = floor(sourceFracIndexCR);\n      vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n      float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n      float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n      float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n      float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n      vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n      float top = topLeft + (topRight - topLeft) * fracCR[0];\n      float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n      float newValue = top + (bottom - top) * fracCR[1];\n\n      gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function resizeBilinear(\n    gpgpu: GPGPUContext, resizeBilinearProgram: WebGLProgram, a: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(resizeBilinearProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {NDArray} from '../ndarray';\n\nexport type Input = {\n  name: string; array: NDArray;\n};\n\nexport function makeShaderKey(inputs: NDArray[], output: NDArray): string {\n  const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC());\n  return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC();\n}\n\nexport function makeShader(\n    inputs: Input[], output: NDArray, userCode: string): string {\n  const inputPrefixSnippet =\n      inputs.map(x => `uniform sampler2D ${x.name};`).join('\\n');\n  const inputSamplingSnippet =\n      inputs.map(x => getInputSamplingSnippet(x)).join('\\n');\n  const outTexShape = output.getTextureShapeRC();\n  const outputSamplingSnippet =\n      getOutputSamplingSnippet(output.shape, outTexShape);\n  const source = [\n    SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet,\n    outputSamplingSnippet, userCode\n  ].join('\\n');\n  return source;\n}\n\nfunction getInputSamplingSnippet(input: Input) {\n  const arr = input.array;\n  const shape = arr.shape;\n  const texShape = arr.getTextureShapeRC(shape as [number, number]);\n  switch (shape.length) {\n    case 2:\n      return getSampler2D(input.name, shape as [number, number], texShape);\n    default:\n      throw new Error(`${arr.rank}-D input sampling is not yet supported`);\n  }\n}\n\nfunction getOutputSamplingSnippet(\n    outShape: number[], outTexShape: [number, number]): string {\n  switch (outShape.length) {\n    case 2:\n      return getOutput2DCoords(outShape as [number, number], outTexShape);\n    default:\n      throw new Error(\n          `${outShape.length}-D output sampling is not yet supported`);\n  }\n}\n\nconst SHADER_PREFIX = `\n  precision highp float;\n  varying vec2 resultUV;\n  const vec2 halfCR = vec2(0.5, 0.5);\n\n  void setOutput(float val) {\n    gl_FragColor = vec4(val, 0, 0, 0);\n  }\n`;\n\nconst SAMPLE_2D_SNIPPET = `\n  float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n      float row, float col) {\n    float index = dot(vec2(row, col), vec2(numC, 1.0));\n    float texR = floor(index / texNumC);\n    float texC = mod(index, texNumC);\n    vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n    return texture2D(texture, uv).r;\n  }\n`;\n\nfunction getOutput2DCoords(\n    shape: [number, number], texShape: [number, number]) {\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      vec2 getOutputCoords() {\n        return floor(gl_FragCoord.yx);\n      }\n    `;\n  }\n  return `\n    vec2 getOutputCoords() {\n      vec2 resTexRC = floor(gl_FragCoord.yx);\n      float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0));\n      float r = floor(index / ${shape[1]}.0);\n      float c = mod(index, ${shape[1]}.0);\n      return vec2(r, c);\n    }\n  `;\n}\n\nfunction getSampler2D(\n    texName: string, shape: [number, number], texShape: [number, number]) {\n  const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1);\n  const tR = texShape[0];\n  const tC = texShape[1];\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      float ${funcName}(float row, float col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0);\n        return texture2D(${texName}, uv).r;\n      }\n    `;\n  }\n  return `\n    float ${funcName}(float row, float col) {\n      return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col);\n    }\n  `;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getSigmoidUnaryOp(): string {\n  return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);';\n}\n\nexport function getSigmoidFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp());\n}\n\nexport function sigmoid(\n    gpgpu: GPGPUContext, sigmoidProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result);\n}\n\nexport function uploadSigmoidDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(\n      a, rows, columns, getSigmoidUnaryOp());\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getStepUnaryOp(): string {\n  return `\n    float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n    gl_FragColor = vec4(res, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp());\n}\n\nexport function step(\n    gpgpu: GPGPUContext, stepProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result);\n}\n\nexport function uploadStepDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getUnpackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns, rows];\n}\n\nexport function getUnpackedArraySizeFromMatrixSize(\n    matrixSize: number, channelsPerTexture: number): number {\n  return matrixSize * channelsPerTexture;\n}\n\nexport function getColorMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns * 4, rows];\n}\n\nexport function getMatrixSizeFromUnpackedArraySize(\n    unpackedSize: number, channelsPerTexture: number): number {\n  if (unpackedSize % channelsPerTexture !== 0) {\n    throw new Error(\n        'unpackedSize (' + unpackedSize + ') must be a multiple of ' +\n        channelsPerTexture);\n  }\n  return unpackedSize / channelsPerTexture;\n}\n\nexport function encodeMatrixToUnpackedArray(\n    matrix: Float32Array, unpackedArray: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize =\n      getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);\n  if (unpackedArray.length < requiredSize) {\n    throw new Error(\n        'unpackedArray length (' + unpackedArray.length +\n        ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < matrix.length; ++src) {\n    unpackedArray[dst] = matrix[src];\n    dst += channelsPerTexture;\n  }\n}\n\nexport function decodeMatrixFromUnpackedArray(\n    unpackedArray: Float32Array, matrix: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize = getMatrixSizeFromUnpackedArraySize(\n      unpackedArray.length, channelsPerTexture);\n  if (matrix.length < requiredSize) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) {\n    matrix[dst++] = unpackedArray[src];\n  }\n}\n\nexport function getPackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [Math.ceil(columns / 2), Math.ceil(rows / 2)];\n}\n\nexport function getPackedRGBAArraySizeFromMatrixShape(\n    rows: number, columns: number): number {\n  const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  return w * h * 4;\n}\n\nexport function encodeMatrixToPackedRGBA(\n    matrix: Float32Array, rows: number, columns: number,\n    packedRGBA: Float32Array) {\n  const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);\n  if (packedRGBA.length < requiredSize) {\n    throw new Error(\n        'packedRGBA length (' + packedRGBA.length +\n        ') must be >= ' + requiredSize);\n  }\n  /*\n    Unpacked matrix, row-major order in Float32Array[16]:  A B C D\n                                                           E F G H\n                                                           I J K L\n                                                           M N O P\n\n    Packed matrix, 2x2 RGBA32 texture (memory view):       ABEF CDGH IJMN KLOP\n\n    Packed matrix, 2x2 RGBA32 texture (matrix view):       AB|CD\n                                                           EF|GH\n                                                           --+--\n                                                           IJ|KL\n                                                           MN|OP\n   */\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n\n  // loop over full 2x2 blocks\n  {\n    const dstStride = (oddWidth ? 4 : 0);\n    const oneRow = columns;\n    let dst = 0;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      const matrixSrcRow = (blockY * 2 * columns);\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        const matrixSrcCol = blockX * 2;\n        const src = matrixSrcRow + matrixSrcCol;\n        packedRGBA[dst] = matrix[src];\n        packedRGBA[dst + 1] = matrix[src + 1];\n        packedRGBA[dst + 2] = matrix[src + oneRow];\n        packedRGBA[dst + 3] = matrix[src + oneRow + 1];\n        dst += 4;\n      }\n      dst += dstStride;\n    }\n  }\n\n  // loop down final odd column\n  if (oddWidth) {\n    let src = columns - 1;\n    let dst = (textureWidth - 1) * 4;\n    const srcStride = 2 * columns;\n    const dstStride = textureWidth * 4;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      packedRGBA[dst] = matrix[src];\n      packedRGBA[dst + 2] = matrix[src + columns];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (rows - 1) * columns;\n    let dst = (textureHeight - 1) * textureWidth * 4;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      packedRGBA[dst++] = matrix[src++];\n      packedRGBA[dst++] = matrix[src++];\n      dst += 2;\n    }\n  }\n\n  // fill in bottom-right texel\n  if (oddWidth && oddHeight) {\n    packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];\n  }\n\n  return packedRGBA;\n}\n\nexport function decodeMatrixFromPackedRGBA(\n    packedRGBA: Float32Array, rows: number, columns: number,\n    matrix: Float32Array): Float32Array {\n  const requiredSize = rows * columns;\n  if (requiredSize < matrix.length) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  // loop over full 2x2 blocks\n  {\n    const srcStride = oddWidth ? 4 : 0;\n    const dstStride = columns + (oddWidth ? 1 : 0);\n    let src = 0;\n    let dstRow1 = 0;\n    let dstRow2 = columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n      }\n      src += srcStride;\n      dstRow1 += dstStride;\n      dstRow2 += dstStride;\n    }\n  }\n\n  // loop down final column\n  if (oddWidth) {\n    let src = (textureWidth - 1) * 4;\n    let dst = columns - 1;\n    const srcStride = textureWidth * 4;\n    const dstStride = 2 * columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      matrix[dst] = packedRGBA[src];\n      matrix[dst + columns] = packedRGBA[src + 2];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (textureHeight - 1) * textureWidth * 4;\n    let dst = (rows - 1) * columns;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      matrix[dst++] = packedRGBA[src++];\n      matrix[dst++] = packedRGBA[src++];\n      src += 2;\n    }\n  }\n\n  // fill in bottom-right cell\n  if (oddWidth && oddHeight) {\n    matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];\n  }\n\n  return matrix;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport class TextureManager {\n  private numUsedTextures = 0;\n  private numFreeTextures = 0;\n  private freeTextures: {[shape: string]: WebGLTexture[]} = {};\n  private logEnabled = false;\n  private usedTextureCount: {[shape: string]: number} = {};\n\n  constructor(private gpgpu: GPGPUContext) {}\n\n  acquireTexture(shapeRC: [number, number]): WebGLTexture {\n    const shapeKey = getKeyFromTextureShape(shapeRC);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    if (!(shapeKey in this.usedTextureCount)) {\n      this.usedTextureCount[shapeKey] = 0;\n    }\n    this.usedTextureCount[shapeKey]++;\n\n    if (this.freeTextures[shapeKey].length > 0) {\n      this.numFreeTextures--;\n      this.numUsedTextures++;\n      this.log();\n      return this.freeTextures[shapeKey].shift()!;\n    }\n    this.numUsedTextures++;\n    this.log();\n\n    return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]);\n  }\n\n  releaseTexture(texture: WebGLTexture, shape: [number, number]): void {\n    const shapeKey = getKeyFromTextureShape(shape);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    this.freeTextures[shapeKey].push(texture);\n    this.numFreeTextures++;\n    this.numUsedTextures--;\n    this.usedTextureCount[shapeKey]--;\n    this.log();\n  }\n\n  private log() {\n    if (!this.logEnabled) {\n      return;\n    }\n    const total = this.numFreeTextures + this.numUsedTextures;\n    console.log(\n        'Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures,\n        `(${total})`);\n  }\n\n  getNumUsedTextures(): number {\n    return this.numUsedTextures;\n  }\n\n  getNumFreeTextures(): number {\n    return this.numFreeTextures;\n  }\n\n  dispose() {\n    for (const shape in this.freeTextures) {\n      if (this.freeTextures.hasOwnProperty(shape)) {\n        for (let i = 0; i < this.freeTextures[shape].length; i++) {\n          this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]);\n        }\n      }\n    }\n  }\n}\n\nfunction getKeyFromTextureShape(shapeRowsCol: [number, number]): string {\n  return shapeRowsCol[0] + '_' + shapeRowsCol[1];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\n/**\n * Sine\n */\nfunction getSinUnaryOp(): string {\n  return `\n    gl_FragColor = vec4(sin(value), 0, 0, 0);\n  `;\n}\n\nexport function getSinFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp());\n}\n\nexport function sin(\n    gpgpu: GPGPUContext, sinProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result);\n}\n\nexport function uploadSinDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp());\n}\n\n/**\n * Tanh\n */\nfunction getTanhUnaryOp(): string {\n  return `\n    float e2x = exp(-2.0 * value);\n    gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n  `;\n}\n\nexport function getTanhFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp());\n}\n\nexport function tanh(\n    gpgpu: GPGPUContext, tanhProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result);\n}\n\nexport function uploadTanhDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(resultOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    void main() {\n      float value = texture2D(matrixA, resultUV).r;\n      ${resultOp}\n    }`;\n}\n\nexport function unaryOp(\n    gpgpu: GPGPUContext, unaryOpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(unaryOpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadUnaryOpDownload(\n    a: Float32Array, rows: number, columns: number,\n    resultOp: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const fragmentShaderSrc = getFragmentShaderSource(resultOp);\n  const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSrc);\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nlet USE_WEBGL2_WHEN_AVAILABLE = false;\nlet WEBGL2_ENABLED: boolean|undefined = null!;\nlet MAX_TEXTURE_SIZE: number = null!;\n\nimport * as util from '../../util';\n\nexport interface WebGLContextAttributes {\n  alpha?: boolean;\n  antialias?: boolean;\n  premultipliedAlpha?: boolean;\n  preserveDrawingBuffer?: boolean;\n  depth?: boolean;\n  stencil?: boolean;\n  failIfMajorPerformanceCaveat?: boolean;\n}\n\n/** @hidden */\nexport const IS_NAN_SHADER_FUNC = `\nbool isNaN(float val) {\n  return val == val ? false : true;\n}\n`;\n\nexport interface WebGLLoseContextExtension { loseContext(): void; }\n\nexport function createWebGLRenderingContext(attributes: WebGLContextAttributes):\n    WebGLRenderingContext {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return createWebGLRenderingContextFromCanvas(canvas, attributes);\n}\n\n/**\n * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL\n * 2.0 is available.\n */\nexport function preferWebGL1() {\n  USE_WEBGL2_WHEN_AVAILABLE = false;\n  WEBGL2_ENABLED = undefined;\n}\n\n/**\n * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration.\n */\nexport function preferWebGL2() {\n  USE_WEBGL2_WHEN_AVAILABLE = true;\n  WEBGL2_ENABLED = undefined;\n}\n\nexport function isWebGL2Enabled() {\n  if (!USE_WEBGL2_WHEN_AVAILABLE) {\n    return false;\n  }\n\n  if (WEBGL2_ENABLED === undefined) {\n    const tempCanvas = document.createElement('canvas');\n    const gl = tempCanvas.getContext('webgl2');\n    if (gl != null) {\n      WEBGL2_ENABLED = true;\n\n      const loseContextExtension =\n          getExtensionOrThrow(\n              gl as WebGLRenderingContext, 'WEBGL_lose_context') as\n          WebGLLoseContextExtension;\n      loseContextExtension.loseContext();\n    } else {\n      WEBGL2_ENABLED = false;\n    }\n  }\n  return WEBGL2_ENABLED;\n}\n\nexport function createWebGLRenderingContextFromCanvas(\n    canvas: HTMLCanvasElement,\n    attributes: WebGLContextAttributes): WebGLRenderingContext {\n  let gl: WebGLRenderingContext;\n  if (isWebGL2Enabled()) {\n    gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext;\n  } else {\n    gl = (canvas.getContext('webgl', attributes) ||\n          canvas.getContext('experimental-webgl', attributes)) as\n        WebGLRenderingContext;\n  }\n\n  if (gl == null) {\n    throw new Error('This browser does not support WebGL.');\n  }\n  return gl;\n}\n\nexport function callAndCheck<T>(gl: WebGLRenderingContext, func: () => T): T {\n  const returnValue = func();\n  checkWebGLError(gl);\n  return returnValue;\n}\n\nlet webGLDebugErrorCheckingEnabled = false;\n\nexport function enableDebugWebGLErrorChecking(enabled: boolean) {\n  webGLDebugErrorCheckingEnabled = enabled;\n}\n\nexport function checkWebGLError(gl: WebGLRenderingContext) {\n  if (webGLDebugErrorCheckingEnabled) {\n    const error = gl.getError();\n    if (error !== gl.NO_ERROR) {\n      throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error));\n    }\n  }\n}\n\nexport function getWebGLErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.NO_ERROR:\n      return 'NO_ERROR';\n    case gl.INVALID_ENUM:\n      return 'INVALID_ENUM';\n    case gl.INVALID_VALUE:\n      return 'INVALID_VALUE';\n    case gl.INVALID_OPERATION:\n      return 'INVALID_OPERATION';\n    case gl.INVALID_FRAMEBUFFER_OPERATION:\n      return 'INVALID_FRAMEBUFFER_OPERATION';\n    case gl.OUT_OF_MEMORY:\n      return 'OUT_OF_MEMORY';\n    case gl.CONTEXT_LOST_WEBGL:\n      return 'CONTEXT_LOST_WEBGL';\n    default:\n      return 'Unknown error code ' + status;\n  }\n}\n\nexport function getExtensionOrThrow(\n    gl: WebGLRenderingContext, extensionName: string): {} {\n  return throwIfNull<{}>(\n      gl, () => gl.getExtension(extensionName),\n      'Extension \"' + extensionName + '\" not supported on this browser.');\n}\n\nexport function createVertexShader(\n    gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader {\n  const vertexShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.VERTEX_SHADER),\n      'Unable to create vertex WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource));\n  callAndCheck(gl, () => gl.compileShader(vertexShader));\n  if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(vertexShader));\n    throw new Error('Failed to compile vertex shader.');\n  }\n  return vertexShader;\n}\n\nexport function createFragmentShader(\n    gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader {\n  const fragmentShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.FRAGMENT_SHADER),\n      'Unable to create fragment WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource));\n  callAndCheck(gl, () => gl.compileShader(fragmentShader));\n  if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(fragmentShader));\n    throw new Error('Failed to compile fragment shader.');\n  }\n  return fragmentShader;\n}\n\nexport function createProgram(gl: WebGLRenderingContext): WebGLProgram {\n  return throwIfNull<WebGLProgram>(\n      gl, () => gl.createProgram(), 'Unable to create WebGLProgram.');\n}\n\nexport function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.linkProgram(program));\n  if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Failed to link vertex and fragment shaders.');\n  }\n}\n\nexport function validateProgram(\n    gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.validateProgram(program));\n  if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Shader program validation failed.');\n  }\n}\n\nexport function createStaticVertexBuffer(\n    gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function createStaticIndexBuffer(\n    gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function queryMaxTextureSize(gl: WebGLRenderingContext): number {\n  if (MAX_TEXTURE_SIZE != null) {\n    return MAX_TEXTURE_SIZE;\n  }\n  MAX_TEXTURE_SIZE =\n      callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE));\n  return MAX_TEXTURE_SIZE;\n}\n\nexport function getChannelsPerTexture(): number {\n  if (isWebGL2Enabled()) {\n    return 1;\n  }\n  return 4;\n}\n\nexport function createTexture(gl: WebGLRenderingContext): WebGLTexture {\n  return throwIfNull<WebGLTexture>(\n      gl, () => gl.createTexture(), 'Unable to create WebGLTexture.');\n}\n\nexport function validateTextureSize(\n    gl: WebGLRenderingContext, width: number, height: number) {\n  const maxTextureSize: number = queryMaxTextureSize(gl);\n  if ((width <= 0) || (height <= 0)) {\n    const requested = '[' + width + 'x' + height + ']';\n    throw new Error('Requested texture size ' + requested + ' is invalid.');\n  }\n  if ((width > maxTextureSize) || (height > maxTextureSize)) {\n    const requested = '[' + width + 'x' + height + ']';\n    const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']';\n    throw new Error(\n        'Requested texture size ' + requested +\n        ' greater than WebGL maximum on this browser / GPU ' + max + '.');\n  }\n}\n\nexport function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer {\n  return throwIfNull<WebGLFramebuffer>(\n      gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.');\n}\n\nexport function bindVertexBufferToProgramAttribute(\n    gl: WebGLRenderingContext, program: WebGLProgram, attribute: string,\n    buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number,\n    itemOffsetInBytes: number) {\n  const loc = gl.getAttribLocation(program, attribute);\n  if (loc === -1) {\n    const error = new Error(\n        'Unable to get attribute \"' + attribute + '\" on WebGLProgram.');\n    // tslint:disable-next-line:no-any\n    (error as any).namedVertexAttributeNotFound = attribute;\n    throw error;\n  }\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl,\n      () => gl.vertexAttribPointer(\n          loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes,\n          itemOffsetInBytes));\n  callAndCheck(gl, () => gl.enableVertexAttribArray(loc));\n}\n\nexport function bindTextureUnit(\n    gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n}\n\nexport function unbindTextureUnit(\n    gl: WebGLRenderingContext, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function getProgramUniformLocationOrThrow(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    uniformName: string): WebGLUniformLocation {\n  return throwIfNull<WebGLUniformLocation>(\n      gl, () => gl.getUniformLocation(program, uniformName),\n      'uniform \"' + uniformName + '\" not present in program.');\n}\n\nexport function bindTextureToProgramUniformSampler(\n    gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture,\n    uniformSamplerName: string, textureUnit: number) {\n  callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit));\n  const samplerLocation =\n      getProgramUniformLocationOrThrow(gl, program, uniformSamplerName);\n  callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit));\n}\n\nexport function bindCanvasToFramebuffer(gl: WebGLRenderingContext) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n  callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height));\n  callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height));\n}\n\nexport function bindColorTextureToFramebuffer(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0));\n}\n\nexport function unbindColorTextureFromFramebuffer(\n    gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0));\n}\n\nexport function validateFramebuffer(gl: WebGLRenderingContext) {\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new Error(\n        'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status));\n  }\n}\n\nexport function getFramebufferErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n      return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS';\n    case gl.FRAMEBUFFER_UNSUPPORTED:\n      return 'FRAMEBUFFER_UNSUPPORTED';\n    default:\n      return 'unknown error ' + status;\n  }\n}\n\nfunction throwIfNull<T>(\n    gl: WebGLRenderingContext, returnTOrNull: () => T | null,\n    failureMessage: string): T {\n  const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull());\n  if (tOrNull == null) {\n    throw new Error(failureMessage);\n  }\n  return tOrNull as T;\n}\n\nfunction validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) {\n  const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;\n  const glTextureUnit = textureUnit + gl.TEXTURE0;\n  if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) {\n    const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']';\n    throw new Error('textureUnit must be in ' + textureUnitRange + '.');\n  }\n}\n\nexport function getTextureShapeFromLogicalShape(\n    gl: WebGLRenderingContext, logicalShape: number[],\n    preferredTexShape?: [number, number]): [number, number] {\n  const maxTexSize = queryMaxTextureSize(gl);\n  const size = util.sizeFromShape(logicalShape);\n  if (preferredTexShape != null) {\n    const sizePreferred = util.sizeFromShape(preferredTexShape);\n    util.assert(\n        size === sizePreferred,\n        `Size of shape (${size}) must match size of ` +\n            `preferredShape (${sizePreferred})`);\n    if (preferredTexShape[0] <= maxTexSize &&\n        preferredTexShape[1] <= maxTexSize) {\n      return preferredTexShape;\n    }\n  }\n\n  if (logicalShape.length <= 1 && size <= maxTexSize) {\n    return [size, 1];\n  } else if (\n      logicalShape.length === 2 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] <= maxTexSize) {\n    return logicalShape as [number, number];\n  } else if (\n      logicalShape.length === 3 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] * logicalShape[2] <= maxTexSize) {\n    return [logicalShape[0], logicalShape[1] * logicalShape[2]];\n  } else {\n    return util.sizeToSquarishShape(size);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {AddNode, ArgMaxEqualsNode, ArgMaxNode, Concat3DNode, Convolution2DNode, DivideNode, ExpNode, FusedLinearCombinationNode, Graph, LogNode, MatMulNode, MaxPoolNode, MeanSquaredCostNode, MultiplyNode, Node, ReduceSumNode, ReLUNode, ReshapeNode, SigmoidNode, SoftmaxCrossEntropyCostNode, SoftmaxNode, SplitNode, SquareNode, SubtractNode, TanHNode, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {Add} from './ops/add';\nimport {ArgMax} from './ops/argmax';\nimport {ArgMaxEquals} from './ops/argmaxequals';\nimport {Concat3D} from './ops/concat3d';\nimport {Convolution2D} from './ops/convolution';\nimport {Divide} from './ops/divide';\nimport {ReLU, Sigmoid, Square, TanH} from './ops/element_wise_activation';\nimport {MeanSquaredCost} from './ops/element_wise_cost';\nimport {Exp} from './ops/exp';\nimport {LinearCombination} from './ops/linear_combination';\nimport {Log} from './ops/log';\nimport {MatMul} from './ops/matmul';\nimport {MaxPool} from './ops/max_pool';\nimport {Multiply} from './ops/multiply';\nimport {Operation} from './ops/op';\nimport {ReduceSum} from './ops/reduce_sum';\nimport {Reshape} from './ops/reshape';\nimport {Softmax, SoftmaxCrossEntropyCost} from './ops/softmax';\nimport {Split} from './ops/split';\nimport {Subtract} from './ops/subtract';\n\nexport function emitFromGraphNodes(nodes: Node[]): Operation[] {\n  const ops: Operation[] = [];\n  nodes.forEach(node => Array.prototype.push.apply(ops, emitOpFromNode(node)));\n  return ops;\n}\n\nfunction emitOpFromNode(node: Node): Operation[] {\n  if (node instanceof ReshapeNode) {\n    return [new Reshape(node.inputs[ReshapeNode.X], node.output)];\n  } else if (node instanceof MatMulNode) {\n    const x1 = node.inputs[MatMulNode.X1];\n    const x2 = node.inputs[MatMulNode.X2];\n    return [new MatMul(x1, x2, node.output)];\n  } else if (node instanceof Convolution2DNode) {\n    const w = node.inputs[Convolution2DNode.W];\n    const x = node.inputs[Convolution2DNode.X];\n    const b = node.inputs[Convolution2DNode.B];\n    return [new Convolution2D(\n        w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride,\n        node.zeroPad)];\n  } else if (node instanceof MaxPoolNode) {\n    const x = node.inputs[MaxPoolNode.X];\n    return [new MaxPool(\n        x, node.output, node.fieldSize, node.stride, node.zeroPad)];\n  } else if (node instanceof ExpNode) {\n    return [new Exp(node.inputs[ExpNode.X], node.output)];\n  } else if (node instanceof LogNode) {\n    return [new Log(node.inputs[LogNode.X], node.output)];\n  } else if (node instanceof ReLUNode) {\n    return [new ReLU(node.inputs[ReLUNode.X], node.output)];\n  } else if (node instanceof TanHNode) {\n    return [new TanH(node.inputs[TanHNode.X], node.output)];\n  } else if (node instanceof SigmoidNode) {\n    return [new Sigmoid(node.inputs[SigmoidNode.X], node.output)];\n  } else if (node instanceof SoftmaxCrossEntropyCostNode) {\n    const x = node.inputs[SoftmaxCrossEntropyCostNode.X];\n    const target = node.inputs[SoftmaxCrossEntropyCostNode.TARGET];\n    return [new SoftmaxCrossEntropyCost(x, target, node.output)];\n  } else if (node instanceof SoftmaxNode) {\n    return [new Softmax(node.inputs[SoftmaxNode.X], node.output)];\n  } else if (node instanceof MeanSquaredCostNode) {\n    const label = node.inputs[MeanSquaredCostNode.LABEL];\n    const prediction = node.inputs[MeanSquaredCostNode.PREDICTION];\n    return [new MeanSquaredCost(label, prediction, node.output)];\n  } else if (node instanceof ArgMaxEqualsNode) {\n    return [new ArgMaxEquals(\n        node.inputs[ArgMaxEqualsNode.X1], node.inputs[ArgMaxEqualsNode.X2],\n        node.output)];\n  } else if (node instanceof ArgMaxNode) {\n    return [new ArgMax(node.x, node.output)];\n  } else if (node instanceof FusedLinearCombinationNode) {\n    return [new LinearCombination(\n        node.inputs[FusedLinearCombinationNode.T1],\n        node.inputs[FusedLinearCombinationNode.T2],\n        node.inputs[FusedLinearCombinationNode.C1],\n        node.inputs[FusedLinearCombinationNode.C2], node.output)];\n  } else if (node instanceof Concat3DNode) {\n    return [new Concat3D(\n        node.inputs[Concat3DNode.X1], node.inputs[Concat3DNode.X2], node.axis,\n        node.output)];\n  } else if (node instanceof SquareNode) {\n    return [new Square(node.inputs[SquareNode.X], node.output)];\n  } else if (node instanceof AddNode) {\n    return [new Add(\n        node.inputs[AddNode.T1], node.inputs[AddNode.T2], node.output)];\n  } else if (node instanceof SubtractNode) {\n    return [new Subtract(\n        node.inputs[SubtractNode.T1], node.inputs[SubtractNode.T2],\n        node.output)];\n  } else if (node instanceof MultiplyNode) {\n    return [new Multiply(\n        node.inputs[MultiplyNode.T1], node.inputs[MultiplyNode.T2],\n        node.output)];\n  } else if (node instanceof DivideNode) {\n    return [new Divide(\n        node.inputs[DivideNode.T1], node.inputs[DivideNode.T2], node.output)];\n  } else if (node instanceof SplitNode) {\n    return [new Split(node.inputs[SplitNode.X], node.outputs)];\n  } else if (node instanceof ReduceSumNode) {\n    return [new ReduceSum(node.inputs[ReduceSumNode.X], node.output)];\n  } else if (graph_util.isInputNode(node)) {\n    return [];\n  } else {\n    // tslint:disable-next-line:no-any\n    throw Error('Unsupported node type: ' + (node.constructor as any).name);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Add extends Operation {\n  private dySizeScalar: Scalar;\n\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(x1.shape)) {\n        result = math.scalarPlusArray(x1, x2);\n      } else if (util.isScalarShape(x2.shape)) {\n        result = math.scalarPlusArray(x2, x1);\n      } else {\n        result = math.add(x1, x2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x1Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x1Tensor, dy);\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x2Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x2Tensor, dy);\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMax extends Operation {\n  /**\n   * An ArgMax operation.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMax(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMax backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMaxEquals extends Operation {\n  /**\n   * An ArgMaxEquals operation.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMaxEquals(x1, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMaxEquals backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as concat3d_util from '../math/concat3d_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Concat3D extends Operation {\n  /**\n   * A Concat 3D operation.\n   *\n   * Concats two 3D tensors along an axis.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor, private axis: number,\n      private yTensor: Tensor) {\n    super();\n    concat3d_util.assertConcat3DShapesMatch(\n        x1Tensor.shape, x2Tensor.shape, axis);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor) as Array3D;\n    const x2 = inferenceArrays.get(this.x2Tensor) as Array3D;\n\n    math.scope((keep) => {\n      const concatResult = math.concat3D(x1, x2, this.axis);\n      inferenceArrays.set(this.yTensor, keep(concatResult));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('Concat3D backprop not implemented.');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Convolution2D extends Operation {\n  private zeroPad: number;\n\n  /**\n   * Constructs a convolution op with the specified properties.\n   *\n   * @param inputShape The shape of the input ndarray.\n   * @param fieldSize The size of the filter (rows/cols of sliding window).\n   * @param outputDepth The depth of the output (Number of filters).\n   * @param stride How many pixels to shift the filter by when sliding.\n   *     Defaults to 1.\n   * @param zeroPad How many pixels to pad the input from each side. Defaults to\n   *     a value so that the rows and columns of the output ndarray is\n   *     the same as the input ndarray.\n   * @param weights Optional. The weights of the filters.\n   * @param biases Optional. The bias terms of the filters.\n   */\n  constructor(\n      private wTensor: Tensor, private xTensor: Tensor, private bTensor: Tensor,\n      private yTensor: Tensor, private fieldSize: number,\n      private outputDepth: number, private stride = 1, zeroPad?: number) {\n    super();\n    this.assertWeightsShape(wTensor.shape);\n    this.zeroPad = zeroPad != null ?\n        zeroPad :\n        conv_util.computeDefaultPad(\n            this.xTensor.shape as [number, number, number], this.fieldSize,\n            this.stride);\n    util.assert(\n        util.isInt(this.zeroPad),\n        `The zero padding (${this.zeroPad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const biases = inferenceArrays.get(this.bTensor) as Array1D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.conv2d(x, weights, biases, this.stride, this.zeroPad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      const {dw, db, dx} =\n          math.conv2dBackProp(x, dy, weights, this.stride, this.zeroPad);\n      gradientArrays.set(this.wTensor, keep(dw));\n      gradientArrays.set(this.bTensor, keep(db));\n      gradientArrays.set(this.xTensor, keep(dx));\n    });\n  }\n\n  private assertWeightsShape(weightsShape: number[]) {\n    util.assert(\n        weightsShape[0] === this.fieldSize &&\n            weightsShape[1] === this.fieldSize &&\n            weightsShape[2] === this.xTensor.shape[2] &&\n            weightsShape[3] === this.outputDepth,\n        `weights must be of shape [${this.fieldSize},${this.fieldSize},` +\n            `${this.xTensor.shape[2]},${this.outputDepth}] but they are of` +\n            `shape [${weightsShape}]`);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Divide extends Operation {\n  private ones: NDArray;\n\n  /**\n   * Element-wise divide operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarDividedByArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayDividedByScalar(t1, t2);\n      } else {\n        result = math.divide(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    const x1IsScalar = util.isScalarShape(x1.shape);\n    const x2IsScalar = util.isScalarShape(x2.shape);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (x1IsScalar) {\n          const div = math.divide(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(div)));\n\n          div.dispose();\n        } else if (x2IsScalar) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.divide(dy, x2)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        // dx2 = -1 * x1 * x2 ^ -2.\n        const x2Squared = math.elementWiseMul(x2, x2);\n\n        let x1OverX2Squared: NDArray;\n        if (x2IsScalar) {\n          x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared);\n        } else if (x1IsScalar) {\n          x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared);\n        } else {\n          x1OverX2Squared = math.divide(x1, x2Squared);\n        }\n\n        const dx2 = math.neg(x1OverX2Squared);\n        const dyTimesDerivative = math.elementWiseMul(dy, dx2);\n\n        if (x2IsScalar) {\n          gradientArrays.set(this.x2Tensor, keep(math.sum(dyTimesDerivative)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(dyTimesDerivative));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {ActivationFunction, ReLUFunc, SigmoidFunc, SquareFunc, TanHFunc} from '../math/activation_functions';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseActivation extends Operation {\n  constructor(\n      protected xTensor: Tensor, protected yTensor: Tensor,\n      private func: ActivationFunction) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(this.func.output(math, x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    // dE/dx_i = sum_j dE/dy_j * dy_j/dx_i\n    //         = dE/dy_i * dy_i/dx_i\n    const x = inferenceArrays.get(this.xTensor);\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      const dydx = this.func.der(math, x, y);\n      gradientArrays.set(this.xTensor, keep(math.elementWiseMul(dy, dydx)));\n      dydx.dispose();\n    });\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReLU extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new ReLUFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class TanH extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new TanHFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Sigmoid extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SigmoidFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Square extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SquareFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {ElementWiseCostFunction, SquareCostFunc} from '../math/cost_functions';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseCost<T extends NDArray> extends Operation {\n  private oneOverNScalar: Scalar;\n\n  constructor(\n      protected x1Tensor: Tensor, protected x2Tensor: Tensor,\n      protected yTensor: Tensor, protected func: ElementWiseCostFunction) {\n    super();\n    this.oneOverNScalar = Scalar.new(1 / util.sizeFromShape(x1Tensor.shape));\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      const elementWiseCost = this.func.cost(math, x1, x2);\n      const sum = math.sum(elementWiseCost);\n      const result = math.scalarTimesArray(this.oneOverNScalar, sum);\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(this.func.der(math, x1, x2)));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(this.func.der(math, x2, x1)));\n      }\n    });\n  }\n\n  dispose() {\n    this.func.dispose();\n    this.oneOverNScalar.dispose();\n  }\n}\n\n/**\n * @hidden\n */\nexport class MeanSquaredCost extends ElementWiseCost<Array1D> {\n  constructor(x1Tensor: Tensor, x2Tensor: Tensor, yTensor: Tensor) {\n    super(x1Tensor, x2Tensor, yTensor, new SquareCostFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Exp extends Operation {\n  /**\n   * Exponentation operation - e^x.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.exp(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.elementWiseMul(y, dy)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class LinearCombination extends Operation {\n  /**\n   * A 2-tensor linear combination operation.\n   *\n   * Combines tensors x1 and x2 (of the same shape) with weights c1 & c2;\n   * Computes c1*x1 + c2*x2.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private c1Tensor: Tensor, private c2Tensor: Tensor,\n      private outTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor).asScalar();\n    const c2 = inferenceArrays.get(this.c2Tensor).asScalar();\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor);\n    const c2 = inferenceArrays.get(this.c2Tensor);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(math.scalarTimesArray(c1, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(math.scalarTimesArray(c2, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.c1Tensor)) {\n        const dotProduct1 = math.elementWiseMul(x1, dy);\n        gradientArrays.set(this.c1Tensor, keep(math.sum(dotProduct1)));\n      }\n\n      if (graph_util.shouldBackProp(this.c2Tensor)) {\n        const dotProduct2 = math.elementWiseMul(x2, dy);\n        gradientArrays.set(this.c2Tensor, keep(math.sum(dotProduct2)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Log extends Operation {\n  /**\n   * Natural log operation - ln(x)\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.log(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.divide(dy, x)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MatMul extends Operation {\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (x1.shape.length === 2 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor, keep(math.matMul(x1 as Array2D, x2 as Array2D)));\n      } else if (x1.shape.length === 2 && x2.shape.length === 1) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.matrixTimesVector(x1 as Array2D, x2 as Array1D)));\n      } else if (x1.shape.length === 1 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.vectorTimesMatrix(x1 as Array1D, x2 as Array2D)));\n      }\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    let x1 = inferenceArrays.get(this.x1Tensor);\n    let x2 = inferenceArrays.get(this.x2Tensor);\n    let dy = gradientArrays.get(this.yTensor);\n\n    if (x1.shape.length === 1) {\n      x1 = x1.reshape([1, x1.size]);\n      dy = dy.reshape([1, dy.size]);\n    }\n    if (x2.shape.length === 1) {\n      x2 = x2.reshape([x2.size, 1]);\n      dy = dy.reshape([dy.size, 1]);\n    }\n\n    math.scope((keep) => {\n      // y = x1 * x2\n      // dx1 = dy * x2T\n      // dx2 = x1T * dy\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        const dx1 = math.matMul(\n            dy as Array2D, x2 as Array2D, MatrixOrientation.REGULAR,\n            MatrixOrientation.TRANSPOSED);\n        gradientArrays.set(\n            this.x1Tensor,\n            keep(this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        const dx2 = math.matMul(\n            x1 as Array2D, dy as Array2D, MatrixOrientation.TRANSPOSED,\n            MatrixOrientation.REGULAR);\n        gradientArrays.set(\n            this.x2Tensor,\n            keep(this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array2D, Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MaxPool extends Operation {\n  private pad: number;\n\n  constructor(\n      private xTensor: Tensor, private yTensor: Tensor,\n      private fieldSize: number, private stride = 1, pad?: number) {\n    super();\n\n    if (pad != null) {\n      this.pad = pad;\n    } else {\n      this.pad = conv_util.computeDefaultPad(\n          xTensor.shape as [number, number, number], this.fieldSize,\n          this.stride);\n    }\n\n    util.assert(\n        util.isInt(this.pad),\n        `The zero padding (${this.pad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.maxPool(x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor,\n          keep(math.maxPoolBackprop(\n              dy, x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Multiply extends Operation {\n  /**\n   * Element-wise multiply operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarTimesArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.scalarTimesArray(t2, t1);\n      } else {\n        result = math.elementWiseMul(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x2.shape)) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.scalarTimesArray(x2, dy)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.elementWiseMul(x2, dy)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x1);\n\n          gradientArrays.set(this.x2Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x1.shape)) {\n          gradientArrays.set(\n              this.x2Tensor, keep(math.scalarTimesArray(x1, dy)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(math.elementWiseMul(x1, dy)));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\n/**\n * @hidden\n */\nexport abstract class Operation {\n  abstract feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap):\n      void;\n\n  abstract backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap): void;\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {}\n\n  dispose() {}\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ReduceSum extends Operation {\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(private x: Tensor, private outTensor: Tensor) {\n    super();\n    util.assertShapesMatch(outTensor.shape, []);\n  }\n\n  private ones: NDArray;\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.x);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.outTensor, keep(math.sum(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.x)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      const dy = gradientArrays.get(this.outTensor);\n      if (this.ones == null) {\n        const xArray = inferenceArrays.get(this.x);\n        this.ones = NDArray.zerosLike(xArray);\n        this.ones.fill(1);\n      }\n      gradientArrays.set(this.x, keep(math.scalarTimesArray(dy, this.ones)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Reshape<T1 extends NDArray, T2 extends NDArray> extends Operation {\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n    const xSize = util.sizeFromShape(xTensor.shape);\n    const ySize = util.sizeFromShape(yTensor.shape);\n    util.assert(\n        xSize === ySize,\n        `The input size (${xSize}) and output size (${ySize}) must match`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as T1;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor, keep(math.reshape<T1, T2>(x, this.yTensor.shape)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const dy = gradientArrays.get(this.yTensor) as T2;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor, keep(math.reshape<T2, T1>(dy, this.xTensor.shape)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Softmax extends Operation {\n  constructor(private logitsTensor: Tensor, private output: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    return math.scope((keep) => {\n      inferenceArrays.set(this.output, keep(math.softmax(logits)));\n    });\n  }\n\n  backProp() {\n    throw Error('Softmax backprop is not yet implemented');\n  }\n}\n\nexport class SoftmaxCrossEntropyCost extends Operation {\n  constructor(\n      private logitsTensor: Tensor, private labelTensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    this.softmaxTensor = new Tensor(logitsTensor.shape);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    const label = inferenceArrays.get(this.labelTensor) as Array1D;\n\n    math.scope((keep) => {\n      const softmaxResult = math.softmax(logits);\n\n      inferenceArrays.set(this.softmaxTensor, keep(softmaxResult));\n      inferenceArrays.set(\n          this.yTensor,\n          keep(crossEntropyCost(math, softmaxResult, label, this.epsilon)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const softmax = inferenceArrays.get(this.softmaxTensor);\n    const label = inferenceArrays.get(this.labelTensor);\n\n    math.scope((keep) => {\n      gradientArrays.set(this.logitsTensor, keep(math.sub(softmax, label)));\n    });\n  }\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {\n    inferenceArrays.disposeArray(this.softmaxTensor);\n  }\n\n  dispose() {\n    this.epsilon.dispose();\n  }\n\n  private softmaxTensor: Tensor;\n  private epsilon = Scalar.new(1e-5);\n}\n\nexport function crossEntropyCost(\n    math: NDArrayMath, y: Array1D, target: Array1D, epsilon: Scalar): Scalar {\n  util.assert(\n      y.size === target.size, 'The output and target must be the same size');\n\n  return math.scope(() => {\n    const yPlusEps = math.scalarPlusArray(epsilon, y);\n    const logOutput = math.log(yPlusEps);\n    const tarLogOutput = math.elementWiseMul(target, logOutput);\n    const costVector = math.neg(tarLogOutput);\n    return math.sum(costVector);\n  });\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * Split ops are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n */\nexport class Split extends Operation {\n  constructor(private input: Tensor, private outputs: Tensor[]) {\n    super();\n    outputs.forEach(output => {\n      util.assertShapesMatch(input.shape, output.shape);\n    });\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const inputArray = inferenceArrays.get(this.input);\n    this.outputs.forEach(output => {\n      inferenceArrays.set(output, inputArray);\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.input)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      let dx = math.add(\n          gradientArrays.get(this.outputs[0]),\n          gradientArrays.get(this.outputs[1]));\n      // Sum across all the derivatives of the consumers of this node.\n      this.outputs.slice(2).forEach(output => {\n        dx = math.add(dx, gradientArrays.get(output));\n      });\n      gradientArrays.set(this.input, keep(dx));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Subtract extends Operation {\n  private dySizeScalar: Scalar;\n\n  /**\n   * Element-wise subtract operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private t1: Tensor, private t2: Tensor, private outTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(t1.shape) === 1 ||\n            util.sizeFromShape(t2.shape) === 1 ||\n            util.arraysEqual(t1.shape, t2.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarMinusArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayMinusScalar(t1, t2);\n      } else {\n        result = math.sub(t1, t2);\n      }\n      inferenceArrays.set(this.outTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.t1)) {\n        if (util.isScalarShape(this.t1.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t1, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t1, keep(dy));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.t2)) {\n        if (util.isScalarShape(this.t2.shape)) {\n          const sum = math.sum(dy);\n          const negSum = math.neg(sum);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t2, keep(math.divide(negSum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t2, keep(math.neg(dy)));\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {SessionRuntime} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport abstract class Optimizer {\n  protected variableNodes: VariableNode[];\n  protected specifiedVariableNodes: VariableNode[]|null;\n\n  constructor(specifiedVariableList?: Node[]) {\n    if (specifiedVariableList != null) {\n      this.specifiedVariableNodes = specifiedVariableList as VariableNode[];\n    }\n  }\n\n  abstract beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract dispose(): void;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * Default comparison function for the priority queue.\n * @param a The first element to compare.\n * @param b The second element to compare.\n * @return \"a > b\" returns > 0. \"a < b\" returns < 0. \"a === b\" returns 0.\n */\nexport function defaultCompare<T>(a: T, b: T): number {\n  if (a === b) {\n    return 0;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * A Comparator is a user-provided function that compares two T instances. The\n * convention for defaultCompare is expected to be followed to maintain the\n * binary min-heap integrity.\n * @param a The first element to compare.\n * @param b The second element to compare.\n */\nexport type Comparator<T> = (a: T, b: T) => number;\n\n/**\n * IndexObserver is a user-provided callback that informs the caller when an\n * element in the priority queue's binary min-heap has been relocated.\n * @param t The element that was relocated.\n * @param newIndex The new location in the binary min-heap of the element.\n */\nexport type IndexObserver<T> = (t: T, newIndex: number) => void;\n\n/**\n * A priority queue, implemented in terms of a binary min-heap. Lower priority\n * numbers are considered higher priority.\n * enqueue, dequeue, and update are all O(log N) with respect to the number of\n * elements in the queue.\n */\nexport class PriorityQueue<T> {\n  private heap: T[] = [];\n\n  /**\n   * @param comparator A function that compares two queue elements.\n   * @param indexObserver An optional callback raised when the priority queue\n   * changes the order of elements in its min-heap. Useful for tracking the\n   * positions of elements that need updating.\n   */\n  constructor(\n      private comparator: Comparator<T>,\n      private indexObserver?: IndexObserver<T>) {}\n\n  /**\n   * Add an element to the priority queue.\n   * @param t The element to enqueue.\n   */\n  enqueue(t: T) {\n    this.heap.push(t);\n    this.onIndexChanged(t, this.heap.length - 1);\n    this.siftUp(this.heap.length - 1);\n  }\n\n  /**\n   * Remove an element from the priority queue.\n   * @return The element in the priority queue with the highest priority\n   * (lowest numeric priority value).\n   */\n  dequeue(): T {\n    if (this.empty()) {\n      throw new Error('dequeue called on empty priority queue.');\n    }\n    const t = this.heap[0];\n    this.swap(0, this.heap.length - 1);\n    this.heap.pop();\n    this.siftDown(0);\n    return t;\n  }\n\n  /**\n   * Updates an element at the specified index. This can be a full element\n   * replacement, or it can be an in-place update. The priority is assumed to be\n   * changed, and the internal storage is updated. This function is only useful\n   * if the storage index of the updated element is known; construct the\n   * PriorityQueue with an IndexObserver to track element locations.\n   * @param newT The new element to replace in the priority queue.\n   * @param index The index to insert the new element into.\n   */\n  update(newT: T, index: number) {\n    /* If the element is at the very end of the heap, no sifting is necessary,\n     * it can be safely removed. */\n    const last = (index === this.heap.length - 1);\n    if (!last) {\n      this.swap(index, this.heap.length - 1);\n    }\n    this.heap.pop();\n    if (!last) {\n      /* The element at 'index' has been removed, and replaced with whatever was\n       * at the end of the heap. Since that element might have come from a\n       * different subtree (and not be a direct descendant of the node at\n       * 'index'), we might need to sift this new value up instead of down. Test\n       * both directions, and sift to wherever the node needs to go.\n       */\n      if (this.siftUpIndex(index) !== -1) {\n        this.siftUp(index);\n      } else if (this.siftDownIndex(index) !== -1) {\n        this.siftDown(index);\n      }\n    }\n    this.enqueue(newT);\n  }\n\n  /**\n   * Predicate for testing whether the PriorityQueue is empty.\n   * @return True if the PriorityQueue is empty, otherwise False.\n   */\n  empty(): boolean {\n    return this.heap.length === 0;\n  }\n\n  private onIndexChanged(t: T, newIndex: number) {\n    if (this.indexObserver) {\n      this.indexObserver(t, newIndex);\n    }\n  }\n\n  /*\n   * Standard zero-indexed binary heap array layout:\n   *   Parent(N) = Floor((N - 1) / 2)\n   *   LeftChild(N) = (N * 2) + 1\n   *   RightChild(N) = (N * 2) + 2\n   */\n\n  private getParentIndex(index: number): number {\n    if (index === 0) {\n      return -1;\n    }\n    return Math.floor((index - 1) / 2);\n  }\n\n  private getLeftChildIndex(index: number): number {\n    const candidate = index * 2 + 1;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private getRightChildIndex(index: number): number {\n    const candidate = index * 2 + 2;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private siftUpIndex(index: number): number {\n    const parentIndex = this.getParentIndex(index);\n    if (parentIndex === -1) {\n      return -1;\n    }\n    if (this.compare(parentIndex, index) > 0) {\n      return parentIndex;\n    }\n    return -1;\n  }\n\n  private siftUp(index: number) {\n    let siftIndex = this.siftUpIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftUpIndex(index);\n    }\n  }\n\n  private siftDownIndex(index: number): number {\n    if (index >= this.heap.length) {\n      return -1;\n    }\n    let largestChildIndex = index;\n    const leftChildIndex = this.getLeftChildIndex(index);\n    if ((leftChildIndex !== -1) &&\n        (this.compare(leftChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = leftChildIndex;\n    }\n    const rightChildIndex = this.getRightChildIndex(index);\n    if ((rightChildIndex !== -1) &&\n        (this.compare(rightChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = rightChildIndex;\n    }\n    return (largestChildIndex === index) ? -1 : largestChildIndex;\n  }\n\n  private siftDown(index: number) {\n    let siftIndex = this.siftDownIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftDownIndex(index);\n    }\n  }\n\n  private compare(aIndex: number, bIndex: number): number {\n    return this.comparator(this.heap[aIndex], this.heap[bIndex]);\n  }\n\n  private swap(a: number, b: number) {\n    const temp = this.heap[a];\n    this.heap[a] = this.heap[b];\n    this.heap[b] = temp;\n    this.onIndexChanged(this.heap[a], a);\n    this.onIndexChanged(this.heap[b], b);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Node, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as operation_emitter from './operation_emitter';\nimport {Operation} from './ops/op';\nimport {Optimizer} from './optimizer';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * FeedEntry associates a tensor with user-provided NDArray data.\n */\nexport type FeedEntry = {\n  tensor: Tensor,\n  data: NDArray|InputProvider\n};\n\n/**\n * A FeedDictionary holds a map from tensors to user-provided NDArrays. Feed\n * dictionaries represent the 'entry points' of evaluation, since graph nodes\n * that are replaced by feeds don't need to have their input nodes evaluated.\n * Feed dictionaries usually provide NDArray data for Placeholder nodes, but any\n * node in the graph can be replaced by a feed dictionary entry.\n *\n * @hidden\n */\nexport class FeedDictionary {\n  dict: {[tensorID: number]: FeedEntry} = {};\n\n  /**\n   * Optionally construct a FeedDictionary from an array of entries.\n   * @param feedEntries Optional array of FeedEntry objects.\n   */\n  constructor(feedEntries?: FeedEntry[]) {\n    if (feedEntries) {\n      feedEntries.forEach(entry => this.dict[entry.tensor.id] = entry);\n    }\n  }\n}\n\nexport enum CostReduction {\n  NONE,\n  SUM,\n  MEAN\n}\n\n/**\n * A Session maintains the runtime state required to efficiently evaluate nodes.\n * On their own, graph objects are very lightweight logical topologies; they\n * have no relationship with the GPU. Sessions encapsulate the evaluation of\n * nodes, the management of GPU resources, the caching of evaluation paths, and\n * anything else required to evaluate or train a network.\n */\nexport class Session {\n  /**\n   * @param graph The graph to associate with this Session.\n   * @param math The NDArrayMath interface that this Session should use.\n   */\n  constructor(private graph: Graph, private math: NDArrayMath) {}\n\n  /**\n   * Release all system resources associated with this Session.\n   */\n  dispose() {\n    this.activationArrayMap.dispose();\n    Object.keys(this.runtimeCache).forEach(key => {\n      const runtime = this.runtimeCache[key];\n      if (runtime.operations) {\n        runtime.operations.forEach(op => op.dispose());\n      }\n    });\n    this.runtimeCache = {};\n    if (this.batchSizeScalar != null) {\n      this.batchSizeScalar.dispose();\n    }\n    this.oneScalar.dispose();\n  }\n\n  /**\n   * Evaluate a list of tensors, using the provided feed entries to provide\n   * upstream NDArray input.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param tensors The list of tensors to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed values of the tensors.\n   */\n  evalAll(tensors: Tensor[], feedEntries: FeedEntry[]): NDArray[] {\n    return this.math.scope(() => {\n      const feed = new FeedDictionary(feedEntries);\n      const runtime = this.getOrCreateRuntime(tensors, feed);\n\n      const activations = this.activationArrayMap;\n\n      session_util.disposeAndInitializeOperationOutputs(\n          runtime.nodes, activations);\n      session_util.disposeTransientOperationArrays(\n          runtime.operations, this.activationArrayMap, this.gradientArrayMap);\n\n      session_util.addPersistentArraysToTensorArrayMap(\n          runtime.nodes, activations);\n      session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n          feed, activations, this.math);\n\n      runtime.operations.forEach(op => op.feedForward(this.math, activations));\n\n      const results = tensors.map(x => activations.get(x));\n      tensors.forEach(x => activations.delete(x));\n\n      session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n          feed, activations, this.math);\n\n      return results;\n    });\n  }\n\n  /**\n   * Evaluate a tensor, using the provided feed entries to provide\n   * upstream NDArray input.\n   *\n   * @param tensor The tensor to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed value of the tensor.\n   */\n  eval(tensor: Tensor, feedEntries: FeedEntry[]): NDArray {\n    return this.evalAll([tensor], feedEntries)[0];\n  }\n\n  /**\n   * Trains a batch.\n   * Returns a reduced cost if the costReduction parameter is set.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param costTensor A tensor representing the cost to optimize. Should be a\n   * scalar.\n   * @param feedEntries Feed entries for this train run. Provides inputs.\n   * @param batchSize Batch size for this train loop.\n   * @param optimizer An optimizer to perform weight updates.\n   * @param costReduction An option to allow the user to get a summed, averaged,\n   * or no cost back.\n   * @return The reduced cost, if cost reduction is not NONE. The user is\n   * responsible for disposing the cost NDArray between train loops.\n   */\n  train(\n      costTensor: Tensor, feedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, costReduction = CostReduction.NONE): Scalar {\n    util.assert(\n        util.isScalarShape(costTensor.shape),\n        'Cost tensor for training must be a scalar value.');\n\n    if (this.prevBatchSize !== batchSize) {\n      this.prevBatchSize = batchSize;\n      this.batchSizeScalar = Scalar.new(batchSize);\n    }\n\n    const feed = new FeedDictionary(feedEntries);\n    session_util.throwIfFeedDictionaryContainsNDArrays(feed);\n\n    const runtime = this.getOrCreateRuntime([costTensor], feed);\n    const inferenceOperations = runtime.operations;\n    const backPropOperations = runtime.operations.slice().reverse();\n    const activations = this.activationArrayMap;\n    const gradients = this.gradientArrayMap;\n    gradients.set(costTensor, this.oneScalar);\n\n    session_util.addPersistentArraysToTensorArrayMap(\n        runtime.nodes, activations);\n\n    optimizer.beforeBatch(\n        this.math, batchSize, runtime, activations, gradients);\n\n    return this.math.scope((keep, track) => {\n      let cost = track(Scalar.new(0));\n\n      for (let i = 0; i < batchSize; ++i) {\n        session_util.disposeAndInitializeOperationOutputs(\n            runtime.nodes, activations);\n        session_util.disposeAndInitializeOperationInputGradients(\n            runtime.nodes, gradients);\n        session_util.disposeTransientOperationArrays(\n            runtime.operations, activations, gradients);\n\n        session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n            feed, activations, this.math);\n\n        inferenceOperations.forEach(\n            op => op.feedForward(this.math, activations));\n        backPropOperations.forEach(\n            op => op.backProp(this.math, activations, gradients));\n\n        optimizer.afterExample(this.math, runtime, activations, gradients);\n\n        session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n            feed, activations, this.math);\n\n        cost = this.updateCostForExample(\n            cost, activations.get(costTensor), costReduction);\n      }\n\n      optimizer.afterBatch(\n          this.math, batchSize, runtime, activations, gradients);\n\n      return this.updateCostForBatch(cost, costReduction);\n    });\n  }\n\n  private updateCostForExample(\n      totalCost: Scalar, currCost: Scalar,\n      costReduction: CostReduction): Scalar {\n    if (costReduction === CostReduction.MEAN ||\n        costReduction === CostReduction.SUM) {\n      return this.math.add(totalCost, currCost);\n    }\n    return totalCost;\n  }\n\n  private updateCostForBatch(totalCost: Scalar, costReduction: CostReduction):\n      Scalar {\n    if (costReduction === CostReduction.MEAN) {\n      return this.math.divide(totalCost, this.batchSizeScalar);\n    }\n    return totalCost;\n  }\n\n  private getOrCreateRuntime(tensors: Tensor[], feed: FeedDictionary):\n      SessionRuntime {\n    const key = this.makeRuntimeCacheKey(tensors, feed);\n    let runtime = this.runtimeCache[key];\n    if (runtime === undefined) {\n      let nodes =\n          session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed);\n      // In inference mode split nodes are not needed, but their cost is\n      // negligible, and always adding them in allows for caching of 1 runtime\n      // for both train/eval.\n      nodes = session_util.addSplitNodes(nodes);\n      session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes);\n      session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes);\n      const operations = operation_emitter.emitFromGraphNodes(nodes);\n      runtime = {nodes, operations};\n      this.runtimeCache[key] = runtime;\n    }\n\n    return runtime;\n  }\n\n  private makeRuntimeCacheKey(tensors: Tensor[], feed: FeedDictionary): string {\n    return tensors.map(x => x.id).sort().join('_') + '__' +\n        Object.keys(feed.dict).sort().join('_');\n  }\n\n  /** Maps each output tensor of the graph to its activation value. */\n  activationArrayMap = new TensorArrayMap();\n  /** Maps each tensor of the graph to its derivative wrt the cost function. */\n  gradientArrayMap = new TensorArrayMap();\n  private runtimeCache: {[key: string]: SessionRuntime} = {};\n  /** Batch size of the previous train() call. */\n  private prevBatchSize: number;\n  private batchSizeScalar: Scalar;\n  private oneScalar = Scalar.new(1);\n}\n\n/** @hidden */\nexport type SessionRuntime = {\n  nodes: Node[]; operations: Operation[];\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport {Operation} from './ops/op';\nimport {FeedDictionary} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * Creates an array of graph nodes that stop traversal, based on the contents\n * of the provided FeedDictionary. This is a simple 1:1 extraction of nodes from\n * the FeedDictionary.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to scan for termination nodes.\n * @return an array of Nodes which halt traversal when visited.\n */\nexport function getTerminatingNodesFromFeedDictionary(\n    feedDictionary: FeedDictionary): Node[] {\n  return Object.keys(feedDictionary.dict)\n      .map(tensorID => feedDictionary.dict[+tensorID].tensor.node);\n}\n\n/**\n * Given a tensor and a feed dictionary, computes the set of nodes that need to\n * be evaluated to perform inference.\n *\n * @hidden\n * @param evalTensors The list of tensors to eventually be evaluated.\n * @param feedDictionary The populated feed dictionary.\n * @return The set of nodes to evaluate, in evaluation order.\n */\nexport function getOrderedEvaluationSetFromEvalTensor(\n    evalTensors: Tensor[], feedDictionary: FeedDictionary): Node[] {\n  const terminatingNodes =\n      getTerminatingNodesFromFeedDictionary(feedDictionary);\n  const evalNodes = evalTensors.map(x => x.node);\n  const unorderedEvaluationSet =\n      graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes);\n  const orderedEvaluationSet =\n      graph_util.getOrderedEvaluationSet(unorderedEvaluationSet);\n  return orderedEvaluationSet;\n}\n\n/**\n * Traverses the provided node array and adds all persistent node NDArrays to\n * the provided TensorArrayMap.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n * @param tensorArrayMap The map that receives the NDArrays from persistent\n * nodes.\n */\nexport function addPersistentArraysToTensorArrayMap(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode || node instanceof ConstantNode) {\n      tensorArrayMap.set(node.output, node.data);\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function getVariableNodesFromEvaluationSet(evaluationSet: Node[]):\n    VariableNode[] {\n  const nodes: VariableNode[] = [];\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode) {\n      nodes.push(node);\n    }\n  });\n  return nodes;\n}\n\n/**\n * @hidden\n */\nexport function throwIfFeedDictionaryContainsNDArrays(\n    feedDictionary: FeedDictionary) {\n  Object.keys(feedDictionary.dict).forEach(tensorID => {\n    if (feedDictionary.dict[+tensorID].data instanceof NDArray) {\n      throw new Error(\n          'training requires FeedDictionary entries to be InputProviders' +\n          'and not NDArrays.');\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function loadInputsFromFeedDictionaryToTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    let data: NDArray;\n    if (feedEntry.data instanceof NDArray) {\n      data = feedEntry.data as NDArray;\n    } else {\n      const provider = feedEntry.data as InputProvider;\n      data = provider.getNextCopy(math);\n    }\n\n    util.assert(\n        util.arraysEqual(feedEntry.tensor.shape, data.shape),\n        `Error loading FeedEntry: feeding NDArray of shape ${data.shape} ` +\n            `does not match Tensor (id: ${feedEntry.tensor.id}) shape: ` +\n            `${feedEntry.tensor.shape}.`);\n    activations.set(feedEntry.tensor, data);\n  });\n}\n\n\n/**\n * @hidden\n */\nexport function releaseFeedDictionaryInputsFromTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    if (!(feedEntry.data instanceof NDArray)) {\n      const provider = feedEntry.data as InputProvider;\n\n      const feedEntryArray = activations.get(feedEntry.tensor);\n      provider.disposeCopy(math, feedEntryArray);\n    }\n\n    activations.delete(feedEntry.tensor);\n  });\n}\n\n/**\n * Removes all nodes from the provided Node array whose output tensors exist in\n * the provided feed dictionary. After calling this, the Node array should\n * contain zero Placeholder nodes, or the user has failed to provide a feed for\n * a Placeholder node.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to process.\n * @param evaluationSet The array of nodes to remove input nodes from.\n */\nexport function removeFeedDictionaryNodesFromEvaluationSet(\n    feedDictionary: FeedDictionary, evaluationSet: Node[]) {\n  let i = 0;\n  while (i < evaluationSet.length) {\n    const node = evaluationSet[i];\n    if (feedDictionary.dict[node.output.id] != null) {\n      evaluationSet.splice(i, 1);\n    } else {\n      ++i;\n    }\n  }\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from operation outputs and sets\n * the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param tensorArrayMap The map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationOutputs(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (!graph_util.isInputNode(node)) {\n      if (!graph_util.isPassthroughNode(node, tensorArrayMap)) {\n        tensorArrayMap.disposeArray(node.output);\n      }\n      tensorArrayMap.set(node.output, null);\n    }\n  });\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from derivatives of operation\n * inputs and sets the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param gradients The gradient map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationInputGradients(\n    evaluationSet: Node[], gradients: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    Object.keys(node.inputs).forEach(inputName => {\n      const input = node.inputs[inputName];\n      if (gradients.get(input, true) !== gradients.get(node.output, true)) {\n        gradients.disposeArray(input);\n      }\n      gradients.set(input, null);\n    });\n  });\n}\n\n\n/**\n * Calls underlying operation disposeTransientArrays methods which clean up any\n * NDArrays which operations may have created during a run.\n *\n * @hidden\n * @param operationNodes The array of Nodes to traverse.\n * @param outputTensor The tensor being evaluated.\n * @param map The TensorArrayMap to operate on.\n */\nexport function disposeTransientOperationArrays(\n    operations: Operation[], activations: TensorArrayMap,\n    gradients: TensorArrayMap) {\n  operations.forEach(op => op.disposeTransientArrays(activations, gradients));\n}\n\n/**\n * Iterates the provided Node array and throws an exception if there are any\n * Placeholder nodes present. Call after the evaluation set has been pruned with\n * the accompanying FeedDictionary to ensure that all inputs have been resolved.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n */\nexport function throwErrorIfEvaluationSetContainsPlaceholderNodes(\n    evaluationSet: Node[]) {\n  evaluationSet.forEach(node => {\n    if (node instanceof PlaceholderNode) {\n      const shape = '[' + node.output.shape.join(', ') + ']';\n      throw new Error(\n          'Placeholder node \"' + node.name + '\" ' + shape +\n          ' not present in feed dictionary.');\n    }\n  });\n}\n\n/**\n * Injects splits nodes after every node that has multiple consumers.\n *\n * @hidden\n * @param nodes The node list in evaluation order.\n * @return The node list with split nodes injected.\n */\nexport function addSplitNodes(nodes: Node[]): Node[] {\n  const nodeIdToNumConsumers: number[] = [];\n  const nodeIdToSplitNode: {[nodeId: number]: SplitNode} = {};\n\n  // Find nodes that have multiple consumers.\n  nodes.forEach(node => {\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const input = inputTensor.node;\n      if (nodeIdToNumConsumers[input.id] == null) {\n        nodeIdToNumConsumers[input.id] = 0;\n      }\n      nodeIdToNumConsumers[input.id]++;\n      if (nodeIdToNumConsumers[input.id] > 1 &&\n          nodeIdToSplitNode[input.id] == null) {\n        nodeIdToSplitNode[input.id] = new SplitNode(input.graph, inputTensor);\n      }\n    });\n  });\n\n  // Inject a split node after each node that has multiple consumers and\n  // rewire the inputs of the consumers to consume the output tensors of the\n  // split node instead of the original node. Each consumer consumes a\n  // different output tensor so that derivatives are not overwritten.\n  // x-->y  becomes x-->s-->y   where y consumes the 1st output tensor of s\n  // |-->z              |-->z     and z consumes the 2nd output tensor of s\n  const newNodes: Node[] = [];\n  nodes.forEach(node => {\n    newNodes.push(node);\n    if (node.id in nodeIdToSplitNode) {\n      const splitNode = nodeIdToSplitNode[node.id];\n      newNodes.push(splitNode);\n    }\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const inputId = inputTensor.node.id;\n      if (inputId in nodeIdToSplitNode) {\n        node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor();\n      }\n    });\n  });\n  return newNodes;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {SessionRuntime} from './session';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport class SGDOptimizer extends Optimizer {\n  constructor(private learningRate: number, specifiedVariableList?: Node[]) {\n    super(specifiedVariableList);\n  }\n\n  beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    this.variableNodes = this.specifiedVariableNodes == null ?\n        session_util.getVariableNodesFromEvaluationSet(runtime.nodes) :\n        this.specifiedVariableNodes;\n    if (batchSize !== this.prevBatchSize) {\n      this.prevBatchSize = batchSize;\n      this.c = Scalar.new(-this.learningRate / batchSize);\n    }\n    this.variableNodes.forEach(\n        node => this.variableGradients.set(\n            node.output, NDArray.zeros(node.output.shape)));\n  }\n\n  afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const gradient = gradientArrayMap.get(node.output);\n        const accumulatedGradient = this.variableGradients.get(node.output);\n        this.variableGradients.set(\n            node.output, keep(math.add(gradient, accumulatedGradient)));\n        accumulatedGradient.dispose();\n      });\n    });\n  }\n\n  afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const oldVariable = activationArrayMap.get(node.output);\n        const gradient = this.variableGradients.get(node.output);\n        const variable =\n            math.scaledArrayAdd(this.c!, gradient, this.one!, oldVariable);\n        activationArrayMap.set(node.output, keep(variable));\n        node.data = variable;\n\n        oldVariable.dispose();\n      });\n    });\n\n    this.variableGradients.dispose();\n    this.variableGradients = new TensorArrayMap();\n  }\n\n  dispose() {\n    if (this.c != null) {\n      this.c.dispose();\n    }\n    this.one.dispose();\n  }\n\n  setLearningRate(learningRate: number) {\n    this.learningRate = learningRate;\n  }\n\n  private variableGradients = new TensorArrayMap();\n  private prevBatchSize: number;\n  private one = Scalar.new(1);\n  private c: Scalar;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from './graph';\nimport {NDArray} from './math/ndarray';\n\n/**\n * TensorArrayMap is an internal map from Tensor IDs to NDArrays. Since NDArrays\n * can be backed by WebGL textures, the TensorArrayMap is only used inside of a\n * Session.\n */\nexport class TensorArrayMap {\n  /**\n   * Add or replace an entry in the map.\n   * @param tensor The tensor key.\n   * @param array The NDArray value, can be null.\n   */\n  set(tensor: Tensor, array: NDArray|null) {\n    this.dict[tensor.id] = array;\n  }\n\n  /**\n   * Returns the NDArray associated with the provided tensor. Will throw an\n   * exception if the tensor is not a key in the map, or if the associated\n   * NDArray is null.\n   * @param tensor The tensor key.\n   * @param skipChecks False by default. If true will skip all checks.\n   * @return The NDArray associated with the tensor.\n   */\n  get(tensor: Tensor, skipChecks = false): NDArray {\n    if (!skipChecks && this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    const nda = this.dict[tensor.id];\n    if (!skipChecks && nda === null) {\n      throw new Error('tensor ' + tensor.id + ' has null array.');\n    }\n    return nda!;\n  }\n\n  /**\n   * Removes a tensor/NDArray pair from the map.\n   * @param tensor The tensor key.\n   */\n  delete(tensor: Tensor) {\n    delete this.dict[tensor.id];\n  }\n\n  disposeArray(tensor: Tensor) {\n    if (this.dict[tensor.id] === undefined) {\n      return;\n    }\n    const nda = this.dict[tensor.id];\n    if (nda === null) {\n      return;\n    }\n    nda.dispose();\n    this.dict[tensor.id] = null;\n  }\n\n  /**\n   * @return The number of tensor/NDArray pairs in the map.\n   */\n  size(): number {\n    return Object.keys(this.dict).length;\n  }\n\n  /**\n   * Iterate over all contained NDArray values and dispose them.\n   */\n  dispose() {\n    Object.keys(this.dict).forEach(tensorID => {\n      const nda = this.dict[+tensorID];\n      if (nda) {\n        nda.dispose();\n      }\n    });\n    this.dict = {};\n  }\n\n  /**\n   * Tests to see if a tensor has a null associated with it. Throws\n   * if the tensor is not a key in the map.\n   * @param tensor The tensor key.\n   * @return True if the associated NDArray is null, else False.\n   */\n  hasNullArray(tensor: Tensor): boolean {\n    if (this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    return this.dict[tensor.id] === null;\n  }\n\n  private dict: {[tensorID: number]: NDArray | null} = {};\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport type Vector = number[] | Float64Array | Float32Array | Int32Array |\n    Int8Array | Int16Array;\n\n/** Shuffles the array using Fisher-Yates algorithm. */\n// tslint:disable-next-line:no-any\nexport function shuffle(array: any[]|Uint32Array|Int32Array|\n                        Float32Array): void {\n  let counter = array.length;\n  let temp = 0;\n  let index = 0;\n  // While there are elements in the array\n  while (counter > 0) {\n    // Pick a random index\n    index = (Math.random() * counter) | 0;\n    // Decrease counter by 1\n    counter--;\n    // And swap the last element with it\n    temp = array[counter];\n    array[counter] = array[index];\n    array[index] = temp;\n  }\n}\n\n/** Clamps a value to a specified range. */\nexport function clamp(min: number, x: number, max: number): number {\n  return Math.max(min, Math.min(x, max));\n}\n\n/** Returns a sample from a uniform [a, b] distribution. */\nexport function randUniform(a: number, b: number) {\n  return Math.random() * (b - a) + a;\n}\n\n/**\n * Samples from a gaussian distribution.\n *\n * @param mean The mean. Default is 0.\n * @param stdDev The standard deviation. Default is 1.\n */\nexport function randGauss(mean = 0, stdDev = 1, truncated = false): number {\n  let v1: number, v2: number, s: number;\n  do {\n    v1 = 2 * Math.random() - 1;\n    v2 = 2 * Math.random() - 1;\n    s = v1 * v1 + v2 * v2;\n  } while (s > 1);\n\n  const result = Math.sqrt(-2 * Math.log(s) / s) * v1;\n  if (truncated && result > 2) {\n    return randGauss(mean, stdDev, true);\n  }\n  return mean + stdDev * result;\n}\n\n/** Returns squared eucledian distance between two vectors. */\nexport function distSquared(a: Vector, b: Vector): number {\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    const diff = a[i] - b[i];\n    result += diff * diff;\n  }\n  return result;\n}\n\nexport function assert(expr: boolean, msg: string) {\n  if (!expr) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertShapesMatch(\n    shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void {\n  assert(\n      arraysEqual(shapeA, shapeB),\n      errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`);\n}\n\n// tslint:disable-next-line:no-any\nexport function flatten(arr: any[], ret?: number[]): number[] {\n  ret = (ret === undefined ? [] : ret);\n  for (let i = 0; i < arr.length; ++i) {\n    if (Array.isArray(arr[i])) {\n      flatten(arr[i], ret);\n    } else {\n      ret.push(arr[i]);\n    }\n  }\n  return ret;\n}\n\nexport type ArrayData = number|number[]|number[][]|number[][][]|number[][][][];\n\nexport function inferShape(arr: ArrayData): number[] {\n  const shape: number[] = [];\n  while (arr instanceof Array) {\n    shape.push(arr.length);\n    arr = arr[0];\n  }\n  return shape;\n}\n\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\n\nexport function isScalarShape(shape: number[]): boolean {\n  return shape.length === 0;\n}\n\n// tslint:disable-next-line:no-any\nexport function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) {\n  if (n1.length !== n2.length) {\n    return false;\n  }\n  for (let i = 0; i < n1.length; i++) {\n    if (n1[i] !== n2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\n\nexport function tanh(x: number): number {\n  // tslint:disable-next-line:no-any\n  if ((Math as any).tanh != null) {\n    // tslint:disable-next-line:no-any\n    return (Math as any).tanh(x);\n  }\n  if (x === Infinity) {\n    return 1;\n  } else if (x === -Infinity) {\n    return -1;\n  } else {\n    const e2x = Math.exp(2 * x);\n    return (e2x - 1) / (e2x + 1);\n  }\n}\n\nexport function sizeToSquarishShape(size: number): [number, number] {\n  for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) {\n    if (size % a === 0) {\n      return [a, size / a];\n    }\n  }\n  return [1, size];\n}\n\nexport function createShuffledIndices(n: number): Uint32Array {\n  const shuffledIndices = new Uint32Array(n);\n  for (let i = 0; i < n; ++i) {\n    shuffledIndices[i] = i;\n  }\n  shuffle(shuffledIndices);\n  return shuffledIndices;\n}\n"]} diff --git a/demos/homepage/Gemfile b/demos/homepage/Gemfile new file mode 100644 index 0000000000..8b53357a7e --- /dev/null +++ b/demos/homepage/Gemfile @@ -0,0 +1,26 @@ +source "https://rubygems.org" + +# Hello! This is where you manage which Jekyll version is used to run. +# When you want to use a different version, change it below, save the +# file and run `bundle install`. Run Jekyll with `bundle exec`, like so: +# +# bundle exec jekyll serve +# +# This will help ensure the proper Jekyll version is running. +# Happy Jekylling! + +# This is the default theme for new Jekyll sites. You may change this to anything you like. +gem "minima", "~> 2.0" + +# If you want to use GitHub Pages, remove the "gem "jekyll"" above and +# uncomment the line below. To upgrade, run `bundle update github-pages`. +gem "github-pages", group: :jekyll_plugins + +# If you have any plugins, put them here! +group :jekyll_plugins do + gem "jekyll-feed", "~> 0.6" +end + +# Windows does not include zoneinfo files, so bundle the tzinfo-data gem +#gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby] + diff --git a/demos/homepage/Gemfile.lock b/demos/homepage/Gemfile.lock new file mode 100644 index 0000000000..147c3924b8 --- /dev/null +++ b/demos/homepage/Gemfile.lock @@ -0,0 +1,205 @@ +GEM + remote: https://rubygems.org/ + specs: + activesupport (4.2.8) + i18n (~> 0.7) + minitest (~> 5.1) + thread_safe (~> 0.3, >= 0.3.4) + tzinfo (~> 1.1) + addressable (2.5.1) + public_suffix (~> 2.0, >= 2.0.2) + coffee-script (2.4.1) + coffee-script-source + execjs + coffee-script-source (1.12.2) + colorator (1.1.0) + ethon (0.10.1) + ffi (>= 1.3.0) + execjs (2.7.0) + faraday (0.12.2) + multipart-post (>= 1.2, < 3) + ffi (1.9.18) + forwardable-extended (2.6.0) + gemoji (3.0.0) + github-pages (146) + activesupport (= 4.2.8) + github-pages-health-check (= 1.3.5) + jekyll (= 3.4.5) + jekyll-avatar (= 0.4.2) + jekyll-coffeescript (= 1.0.1) + jekyll-default-layout (= 0.1.4) + jekyll-feed (= 0.9.2) + jekyll-gist (= 1.4.0) + jekyll-github-metadata (= 2.5.1) + jekyll-mentions (= 1.2.0) + jekyll-optional-front-matter (= 0.2.0) + jekyll-paginate (= 1.1.0) + jekyll-readme-index (= 0.1.0) + jekyll-redirect-from (= 0.12.1) + jekyll-relative-links (= 0.4.1) + jekyll-sass-converter (= 1.5.0) + jekyll-seo-tag (= 2.2.3) + jekyll-sitemap (= 1.0.0) + jekyll-swiss (= 0.4.0) + jekyll-theme-architect (= 0.0.4) + jekyll-theme-cayman (= 0.0.4) + jekyll-theme-dinky (= 0.0.4) + jekyll-theme-hacker (= 0.0.4) + jekyll-theme-leap-day (= 0.0.4) + jekyll-theme-merlot (= 0.0.4) + jekyll-theme-midnight (= 0.0.4) + jekyll-theme-minimal (= 0.0.4) + jekyll-theme-modernist (= 0.0.4) + jekyll-theme-primer (= 0.3.1) + jekyll-theme-slate (= 0.0.4) + jekyll-theme-tactile (= 0.0.4) + jekyll-theme-time-machine (= 0.0.4) + jekyll-titles-from-headings (= 0.2.0) + jemoji (= 0.8.0) + kramdown (= 1.13.2) + liquid (= 3.0.6) + listen (= 3.0.6) + mercenary (~> 0.3) + minima (= 2.1.1) + rouge (= 1.11.1) + terminal-table (~> 1.4) + github-pages-health-check (1.3.5) + addressable (~> 2.3) + net-dns (~> 0.8) + octokit (~> 4.0) + public_suffix (~> 2.0) + typhoeus (~> 0.7) + html-pipeline (2.6.0) + activesupport (>= 2) + nokogiri (>= 1.4) + i18n (0.8.6) + jekyll (3.4.5) + addressable (~> 2.4) + colorator (~> 1.0) + jekyll-sass-converter (~> 1.0) + jekyll-watch (~> 1.1) + kramdown (~> 1.3) + liquid (~> 3.0) + mercenary (~> 0.3.3) + pathutil (~> 0.9) + rouge (~> 1.7) + safe_yaml (~> 1.0) + jekyll-avatar (0.4.2) + jekyll (~> 3.0) + jekyll-coffeescript (1.0.1) + coffee-script (~> 2.2) + jekyll-default-layout (0.1.4) + jekyll (~> 3.0) + jekyll-feed (0.9.2) + jekyll (~> 3.3) + jekyll-gist (1.4.0) + octokit (~> 4.2) + jekyll-github-metadata (2.5.1) + jekyll (~> 3.1) + octokit (~> 4.0, != 4.4.0) + jekyll-mentions (1.2.0) + activesupport (~> 4.0) + html-pipeline (~> 2.3) + jekyll (~> 3.0) + jekyll-optional-front-matter (0.2.0) + jekyll (~> 3.0) + jekyll-paginate (1.1.0) + jekyll-readme-index (0.1.0) + jekyll (~> 3.0) + jekyll-redirect-from (0.12.1) + jekyll (~> 3.3) + jekyll-relative-links (0.4.1) + jekyll (~> 3.3) + jekyll-sass-converter (1.5.0) + sass (~> 3.4) + jekyll-seo-tag (2.2.3) + jekyll (~> 3.3) + jekyll-sitemap (1.0.0) + jekyll (~> 3.3) + jekyll-swiss (0.4.0) + jekyll-theme-architect (0.0.4) + jekyll (~> 3.3) + jekyll-theme-cayman (0.0.4) + jekyll (~> 3.3) + jekyll-theme-dinky (0.0.4) + jekyll (~> 3.3) + jekyll-theme-hacker (0.0.4) + jekyll (~> 3.3) + jekyll-theme-leap-day (0.0.4) + jekyll (~> 3.3) + jekyll-theme-merlot (0.0.4) + jekyll (~> 3.3) + jekyll-theme-midnight (0.0.4) + jekyll (~> 3.3) + jekyll-theme-minimal (0.0.4) + jekyll (~> 3.3) + jekyll-theme-modernist (0.0.4) + jekyll (~> 3.3) + jekyll-theme-primer (0.3.1) + jekyll (~> 3.3) + jekyll-theme-slate (0.0.4) + jekyll (~> 3.3) + jekyll-theme-tactile (0.0.4) + jekyll (~> 3.3) + jekyll-theme-time-machine (0.0.4) + jekyll (~> 3.3) + jekyll-titles-from-headings (0.2.0) + jekyll (~> 3.3) + jekyll-watch (1.5.0) + listen (~> 3.0, < 3.1) + jemoji (0.8.0) + activesupport (~> 4.0) + gemoji (~> 3.0) + html-pipeline (~> 2.2) + jekyll (>= 3.0) + kramdown (1.13.2) + liquid (3.0.6) + listen (3.0.6) + rb-fsevent (>= 0.9.3) + rb-inotify (>= 0.9.7) + mercenary (0.3.6) + mini_portile2 (2.2.0) + minima (2.1.1) + jekyll (~> 3.3) + minitest (5.10.3) + multipart-post (2.0.0) + net-dns (0.8.0) + nokogiri (1.8.0) + mini_portile2 (~> 2.2.0) + octokit (4.7.0) + sawyer (~> 0.8.0, >= 0.5.3) + pathutil (0.14.0) + forwardable-extended (~> 2.6) + public_suffix (2.0.5) + rb-fsevent (0.10.2) + rb-inotify (0.9.10) + ffi (>= 0.5.0, < 2) + rouge (1.11.1) + safe_yaml (1.0.4) + sass (3.5.1) + sass-listen (~> 4.0.0) + sass-listen (4.0.0) + rb-fsevent (~> 0.9, >= 0.9.4) + rb-inotify (~> 0.9, >= 0.9.7) + sawyer (0.8.1) + addressable (>= 2.3.5, < 2.6) + faraday (~> 0.8, < 1.0) + terminal-table (1.8.0) + unicode-display_width (~> 1.1, >= 1.1.1) + thread_safe (0.3.6) + typhoeus (0.8.0) + ethon (>= 0.8.0) + tzinfo (1.2.3) + thread_safe (~> 0.1) + unicode-display_width (1.3.0) + +PLATFORMS + ruby + +DEPENDENCIES + github-pages + jekyll-feed (~> 0.6) + minima (~> 2.0) + +BUNDLED WITH + 1.15.3 diff --git a/demos/homepage/_config.yml b/demos/homepage/_config.yml new file mode 100644 index 0000000000..a7bcf13a7c --- /dev/null +++ b/demos/homepage/_config.yml @@ -0,0 +1,32 @@ +# Welcome to Jekyll! +# +# This config file is meant for settings that affect your whole blog, values +# which you are expected to set up once and rarely edit after that. If you find +# yourself editing this file very often, consider using Jekyll's data files +# feature for the data you need to update frequently. +# +# For technical reasons, this file is *NOT* reloaded automatically when you use +# 'bundle exec jekyll serve'. If you change this file, please restart the server process. + +# Site settings +# These are used to personalize your new site. If you look in the HTML files, +# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on. +# You can create any custom variable you would like, and they will be accessible +# in the templates via {{ site.myvariable }}. +title: deeplearn.js +baseurl: "" # the subpath of your site, e.g. /blog + +# Build settings +markdown: kramdown +theme: minima +gems: + - jekyll-feed + - jekyll-redirect-from +exclude: + - Gemfile + - Gemfile.lock + - node_modules/ + - bower_components/ + +# deployment +host: 0.0.0.0 diff --git a/demos/homepage/_includes/footer.html b/demos/homepage/_includes/footer.html new file mode 100644 index 0000000000..eca84845e6 --- /dev/null +++ b/demos/homepage/_includes/footer.html @@ -0,0 +1,32 @@ + + + + diff --git a/demos/homepage/_includes/header.html b/demos/homepage/_includes/header.html new file mode 100644 index 0000000000..2c25c16548 --- /dev/null +++ b/demos/homepage/_includes/header.html @@ -0,0 +1,31 @@ + +
+
+ + deeplearn.js + +
+ + +
+
+ +
+ deeplearn.js + +
diff --git a/demos/homepage/_layouts/default.html b/demos/homepage/_layouts/default.html new file mode 100644 index 0000000000..953754325a --- /dev/null +++ b/demos/homepage/_layouts/default.html @@ -0,0 +1,36 @@ + + + + + + deeplearn.js + + + + + + + + +
+ {% include header.html %} +
+ {{ content }} + {% include footer.html %} +
+
+ + diff --git a/demos/homepage/_layouts/page.html b/demos/homepage/_layouts/page.html new file mode 100644 index 0000000000..6b83422475 --- /dev/null +++ b/demos/homepage/_layouts/page.html @@ -0,0 +1,30 @@ +--- +layout: default +--- +
+
+
+
+ {{ content }} +
+
+
+
+ {% assign default_paths = site.pages | map: "path" %} + {% assign page_paths = site.header_pages | default: default_paths %} + + {% if page_paths %} + + {% endif %} +
+
diff --git a/demos/homepage/assets/style.css b/demos/homepage/assets/style.css new file mode 100644 index 0000000000..21575f4f00 --- /dev/null +++ b/demos/homepage/assets/style.css @@ -0,0 +1,280 @@ +html { + width: 100%; + height: 100%; +} +body { + font-family: "Roboto", "Helvetica", "Arial", sans-serif; + margin: 0; + width: 100%; + height: 100%; +} +head { + height: 0; + width: 0; +} +/* Typography */ +p { + font-family: 'Roboto', sans-serif; + line-height: 1.67em; + font-size: 16px; +} +.mdl-list__item a { + text-decoration: none; + color: rgba(0,0,0,0.64); + font-weight: 400; + letter-spacing: 0; +} +.mdl-list__item a:hover { + text-decoration: underline; + color: rgba(0,0,0,0.64); + font-weight: 400; + letter-spacing: 0; +} +.mdl-navigation__link{ + font-family: 'Roboto', sans-serif; +} +.mdl-layout__drawer { + font-family: 'Roboto', sans-serif; +} + +/* CPPN Demo */ +.banner { + background-size: cover; + background-position: center; + min-height: 250px; + padding-top: 64px; + padding-bottom: 32px; + position: relative; +} +.banner-cover { + position: relative; + background: #466368; + background: -webkit-linear-gradient(#c4c4c4, #293f50); + background: -moz-linear-gradient(#c4c4c4, #293f50); + background: linear-gradient(#c4c4c4, #293f50); +} +.banner-text { + color:#fff; +} +.cppn-controls { + min-width: 300px; + max-width: 300px; + padding:24px 24px 60px 24px; + background-color: rgba(255,255,255,0.99); + position: relative; +} +.cppn-demo { + color:#fff; +} +#disabled-demo-overlay { + position: absolute; + width: 100%; + height: 100%; + background-color: rgba(62, 82, 90, .9); + top: 0; + left: 0; +} +#disabled-demo { + margin: auto; + position: absolute; + top: 20%; + left: 0; + right: 0; + padding: 32px; + bottom: 0; + font-size: 18px; + color: white; + font-weight: 400; + text-align: left; + line-height: 1.3325em; + z-index: 2; +} +#inference { + width: 100%; + height: calc(100% + 1px); + position: absolute; +} +.getmdl-select .mdl-icon-toggle__label{ + float:right; + margin-top:-30px; + color:rgba(0,0,0,0.4); +} +/* Introduction */ +.intro-text { + margin: 32px auto 32px auto; +} +.mdl-grid { + max-width: 1200px; +} +.mdl-mini-footer { + margin-top: 72px; +} +.mdl-card__actions { + padding-left: 12px; +} +.intro-headline { + line-height: 1.67em; + font-weight: 300; + color: #888; +} +/* Responsive behavior */ +.intro-text > .mdl-cell--8-col-tablet { + margin-top: 72px; +} +.banner >.mdl-cell--8-col-tablet { + margin: 36px; +} +.resource-tabs { + font-family: 'Roboto', sans-serif; +} + +a { + color: #346f91; + font-size: 16px; +} +a:visited { + color: #346f91; +} +a:hover { + color: #346f91; +} +.mdl-card__actions a:hover { + text-decoration: none; +} + +a.main-title { + color: white; + text-decoration: none; +} + +blockquote { + color: black; + padding: 8px 8px 8px 20px; + border-left-width: 2px; + font-style: normal; + border-left-style: solid; + border-color: #9e9e9e; + background-color: #eee; + margin-bottom: 32px; +} +blockquote:before { + content: none; +} +blockquote:after { + content: none; +} +ul { + margin-left: 16px; + list-style-type: disc; +} +ul ul { + list-style-type: disc; +} +ul ul ul { + list-style-type: disc; +} +ul ul ul ul { + list-style-type: disc; +} +.highlight .err { + color: inherit; + background-color: inherit; +} +table { + border-spacing: 20px; +} +.site-nav { + position: fixed; + float: inherit; +} +.site-nav ul { + margin-top: 32px; + border-left: solid 3px #C0EbF1; + padding-left: 20px; + line-height: 28px; + list-style-type: none; + line-height: 2.7em; + font-weight: normal; +} +.site-nav ul a { + color: #50797f; + font-weight: normal; +} +ul.index { + border-left: 2px solid #346f91; + margin-left: 16px; + margin-top: 16px; + padding-left: 16px; + list-style-type: none; +} +.deeplearn-shine { + color: #777; + font-weight: 500; +} +.demo-card .mdl-card__title { + color: #fff; + height: 176px; +} + +.demo-card .mdl-card__title:before { + content: ''; + height: 176px; + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + background: rgba(53, 71, 80, 0.65); +} + +#model-builder { + background: url('/demos/images/model-builder.png') center / cover; +} + +#webcam { + background: url('/demos/images/imagenet.png') center / cover; +} + +#nnart { + background: url('/demos/images/nn-art.png') center / cover; +} + +#benchmarks { + background: url('/demos/images/benchmark.png') center / cover; +} + +.demo-card .mdl-card__title-text { + color: white; + z-index: 1; + font-weight: 400; +} + +.mdl-typography--display-2, h1, h2, h3, h4 { + color: #414141; + font-weight: 300; +} +code { + background: none; +} +.highlighter-rouge .highlight { + background-color: #f5f5f5; + padding-bottom: 16px; + margin-bottom: 32px; +} + +h2 { + font-size: 40px; +} + +h3 { + font-size: 30px; +} +p.intro-body { + font-weight: 300; +} +.mdl-mini-footer__link-list a { + color: rgb(158, 158, 158); +} +.mdl-mini-footer__link-list a:visited { + color: rgb(158, 158, 158); +} diff --git a/demos/homepage/bundle.js b/demos/homepage/bundle.js new file mode 100644 index 0000000000..fb014c9d2e --- /dev/null +++ b/demos/homepage/bundle.js @@ -0,0 +1,8216 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o " + inputNumDimensions + ".0) {\n gl_FragColor = vec4(z[1], 0, 0, 0);\n } else {\n gl_FragColor = texture2D(source, resultUV);\n }\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getAddLatentVariablesShader = getAddLatentVariablesShader; +function addLatentVariables(gpgpu, addZShader, sourceTex, resultTex, shapeRowCol, z1, z2) { + gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]); + gpgpu.setProgram(addZShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + var zLoc = gpgpu.getUniformLocation('z'); + gpgpu.gl.uniform2f(zLoc, z1, z2); + gpgpu.executeProgram(); +} +exports.addLatentVariables = addLatentVariables; +function getRenderShader(gpgpu, imageSize) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n uniform int colorMode;\n uniform float outputNumDimensions;\n\n const float destinationSize = " + imageSize + ".0;\n\n const mat3 yuv2rgb = mat3(\n 1, 1, 1,\n 0, -.34413, 1.772,\n 1.402, -.71414, 0);\n\n vec3 hsv2rgb(vec3 c) {\n vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n }\n\n void main() {\n vec2 outputCR = floor(gl_FragCoord.xy);\n float inputC = outputCR.y * destinationSize + outputCR.x;\n float u = (inputC + 0.5) / " + imageSize * imageSize + ".0;\n\n vec4 inputR = vec4(0.0, 1.0, 2.0, 3.0);\n vec4 v = (inputR + 0.5) / outputNumDimensions;\n\n vec4 values = vec4(\n texture2D(source, vec2(u, v[0])).r,\n texture2D(source, vec2(u, v[1])).r,\n texture2D(source, vec2(u, v[2])).r,\n texture2D(source, vec2(u, v[3])).r);\n\n if (colorMode == 0) {\n // RGB\n gl_FragColor = vec4(values.rgb, 1.0);\n } else if (colorMode == 1) {\n // RGBA\n gl_FragColor = values;\n } else if (colorMode == 2) {\n // HSV\n vec3 rgb = hsv2rgb(values.rgb);\n gl_FragColor = vec4(rgb, 1.0);\n } else if (colorMode == 3) {\n // HSVA\n vec3 rgb = hsv2rgb(values.rgb);\n gl_FragColor = vec4(rgb, values[3]);\n } else if (colorMode == 4 || colorMode == 5) {\n // YUV\n values[0] = clamp(values[0], 0.2, 0.8);\n values[1] = values[1] - 0.5;\n values[2] = values[2] - 0.5;\n vec3 rgb = yuv2rgb * values.rgb;\n if (colorMode == 4) {\n // YUV\n gl_FragColor = vec4(rgb, 1.0);\n } else if (colorMode == 5) {\n // YUVA\n gl_FragColor = vec4(rgb, values.a);\n }\n } else if (colorMode == 6) {\n gl_FragColor = vec4(values[0], values[0], values[0], 1.0);\n }\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderShader = getRenderShader; +function render(gpgpu, renderShader, sourceTex, outputNumDimensions, colorMode) { + learnjs_1.webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + var colorModeLoc = gpgpu.getUniformLocation('colorMode'); + gpgpu.gl.uniform1i(colorModeLoc, colorMode); + var outputNumDimensionsLoc = gpgpu.getUniformLocation('outputNumDimensions'); + gpgpu.gl.uniform1f(outputNumDimensionsLoc, outputNumDimensions); + gpgpu.executeProgram(); +} +exports.render = render; +function imagePixelToNormalizedCoord(x, y, imageWidth, imageHeight, zSize) { + var halfWidth = imageWidth * 0.5; + var halfHeight = imageHeight * 0.5; + var normX = (x - halfWidth) / imageWidth; + var normY = (y - halfHeight) / imageHeight; + var r = Math.sqrt(normX * normX + normY * normY); + var result = [normX, normY, r]; + for (var i = 0; i < zSize; i++) { + result.push(0); + } + return result; +} +exports.imagePixelToNormalizedCoord = imagePixelToNormalizedCoord; + +},{"../learnjs":2}],5:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var MANIFEST_FILE = 'manifest.json'; +var CheckpointLoader = (function () { + function CheckpointLoader(urlPath) { + this.urlPath = urlPath; + if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') { + this.urlPath += '/'; + } + } + CheckpointLoader.prototype.loadManifest = function () { + var _this = this; + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', _this.urlPath + MANIFEST_FILE); + xhr.onload = function () { + _this.checkpointManifest = JSON.parse(xhr.responseText); + resolve(); + }; + xhr.onerror = function (error) { + throw new Error(MANIFEST_FILE + " not found at " + _this.urlPath + ". " + error); + }; + xhr.send(); + }); + }; + CheckpointLoader.prototype.getCheckpointManifest = function () { + var _this = this; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + resolve(_this.checkpointManifest); + }); + }); + } + return new Promise(function (resolve, reject) { + resolve(_this.checkpointManifest); + }); + }; + CheckpointLoader.prototype.getAllVariables = function () { + var _this = this; + if (this.variables != null) { + return new Promise(function (resolve, reject) { + resolve(_this.variables); + }); + } + return new Promise(function (resolve, reject) { + _this.getCheckpointManifest().then(function (checkpointDefinition) { + var variableNames = Object.keys(_this.checkpointManifest); + var variablePromises = []; + for (var i = 0; i < variableNames.length; i++) { + variablePromises.push(_this.getVariable(variableNames[i])); + } + Promise.all(variablePromises).then(function (variables) { + _this.variables = {}; + for (var i = 0; i < variables.length; i++) { + _this.variables[variableNames[i]] = variables[i]; + } + resolve(_this.variables); + }); + }); + }); + }; + CheckpointLoader.prototype.getVariable = function (varName) { + var _this = this; + if (!(varName in this.checkpointManifest)) { + throw new Error('Cannot load non-existant variable ' + varName); + } + var variableRequestPromiseMethod = function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.responseType = 'arraybuffer'; + var fname = _this.checkpointManifest[varName].filename; + xhr.open('GET', _this.urlPath + fname); + xhr.onload = function () { + var values = new Float32Array(xhr.response); + var ndarray = ndarray_1.NDArray.make(_this.checkpointManifest[varName].shape, { values: values }); + resolve(ndarray); + }; + xhr.onerror = function (error) { + throw new Error('Could not fetch variable ' + varName + ': ' + error); + }; + xhr.send(); + }; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + new Promise(variableRequestPromiseMethod).then(resolve); + }); + }); + } + return new Promise(variableRequestPromiseMethod); + }; + return CheckpointLoader; +}()); +exports.CheckpointLoader = CheckpointLoader; + +},{"./math/ndarray":22}],6:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var STATS_SAMPLE_PERCENTAGE = 0.1; +var InMemoryDataset = (function () { + function InMemoryDataset(dataShapes) { + this.dataShapes = dataShapes; + this.normalizationInfo = {}; + } + InMemoryDataset.prototype.getDataShape = function (dataIndex) { + return this.dataShapes[dataIndex]; + }; + InMemoryDataset.prototype.getData = function () { + return this.dataset; + }; + InMemoryDataset.prototype.getStats = function () { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + return this.dataset.map(function (d) { return _this.getStatsForData(d); }); + }; + InMemoryDataset.prototype.getStatsForData = function (data) { + var inputMin = Number.POSITIVE_INFINITY; + var inputMax = Number.NEGATIVE_INFINITY; + var exampleIndices = data.map(function (example, i) { return i; }); + util.shuffle(exampleIndices); + exampleIndices = + exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE); + for (var i = 0; i < exampleIndices.length; i++) { + var inputValues = data[exampleIndices[i]].getValues(); + for (var j = 0; j < inputValues.length; j++) { + inputMin = Math.min(inputMin, inputValues[j]); + inputMax = Math.max(inputMax, inputValues[j]); + } + } + return { + inputMin: inputMin, + inputMax: inputMax, + exampleCount: data.length, + shape: data[0].shape, + }; + }; + InMemoryDataset.prototype.normalizeExamplesToRange = function (examples, curLowerBounds, curUpperBounds, newLowerBounds, newUpperBounds) { + var curBoundsIsPerDimension = (curUpperBounds instanceof Float32Array && + curLowerBounds instanceof Float32Array); + var newBoundsIsPerDimension = (newLowerBounds instanceof Float32Array && + newUpperBounds instanceof Float32Array); + var inputSize = util.sizeFromShape(examples[0].shape); + var newExamples = []; + examples.forEach(function (example) { + var inputValues = example.getValues(); + var normalizedValues = new Float32Array(inputSize); + for (var j = 0; j < inputSize; j++) { + var curLowerBound = curBoundsIsPerDimension ? + curLowerBounds[j] : + curLowerBounds; + var curUpperBound = curBoundsIsPerDimension ? + curUpperBounds[j] : + curUpperBounds; + var curRange = curUpperBound - curLowerBound; + var newLowerBound = newBoundsIsPerDimension ? + newLowerBounds[j] : + newLowerBounds; + var newUpperBound = newBoundsIsPerDimension ? + newUpperBounds[j] : + newUpperBounds; + var newRange = newUpperBound - newLowerBound; + if (curRange === 0) { + normalizedValues[j] = newLowerBound; + } + else { + normalizedValues[j] = newLowerBound + + newRange * (inputValues[j] - curLowerBound) / curRange; + } + } + newExamples.push(ndarray_1.NDArray.make(example.shape, { values: normalizedValues })); + }); + return newExamples; + }; + InMemoryDataset.prototype.computeBounds = function (dataIndex) { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + var size = util.sizeFromShape(this.dataset[dataIndex][0].shape); + this.normalizationInfo[dataIndex] = { + isNormalized: false, + minValues: new Float32Array(size), + maxValues: new Float32Array(size) + }; + for (var i = 0; i < size; i++) { + this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY; + this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY; + } + this.dataset[dataIndex].forEach(function (example) { + var inputValues = example.getValues(); + for (var k = 0; k < size; k++) { + _this.normalizationInfo[dataIndex].minValues[k] = Math.min(_this.normalizationInfo[dataIndex].minValues[k], inputValues[k]); + _this.normalizationInfo[dataIndex].maxValues[k] = Math.max(_this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]); + } + }); + }; + InMemoryDataset.prototype.normalizeWithinBounds = function (dataIndex, lowerBound, upperBound) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + if (dataIndex >= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":22,"./util":86}],7:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":8,"./math/concat3d_util":15,"./math/conv_util":16,"./math/ndarray":22,"./util":86}],8:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":12}],9:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":22,"./session":82}],10:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":7,"./priority_queue":81}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":5,"./dataset":6,"./graph":7,"./graph_runner":9,"./initializers":12,"./input_provider":13,"./math/conv_util":16,"./math/math":19,"./math/math_cpu":20,"./math/math_gpu":21,"./math/ndarray":22,"./math/webgl/gpgpu_context":35,"./math/webgl/gpgpu_util":36,"./math/webgl/render_ndarray_gpu_util":48,"./math/webgl/webgl_util":58,"./optimizer":80,"./session":82,"./sgd_optimizer":84,"./util":86}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":22}],13:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":22,"./util":86}],14:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":22}],15:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":86}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":86}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":22}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":86,"./concat3d_util":15,"./copy2d_util":17,"./ndarray":22}],20:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":16,"../util":86,"./concat3d_util":15,"./copy2d_util":17,"./math":19,"./ndarray":22}],21:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":86,"./concat3d_util":15,"./conv_util":16,"./math":19,"./ndarray":22,"./webgl/addscaledmat_gpu":23,"./webgl/addsubmuldiv_gpu":24,"./webgl/argmaxequals_gpu":25,"./webgl/argminmax_gpu":26,"./webgl/avg_pool_gpu":27,"./webgl/batchnorm_gpu":28,"./webgl/concat3d_gpu":30,"./webgl/conv_backprop_gpu":31,"./webgl/conv_gpu":32,"./webgl/copy_gpu":33,"./webgl/exp_gpu":34,"./webgl/gpgpu_context":35,"./webgl/gpgpu_util":36,"./webgl/log_gpu":37,"./webgl/logsumexp_gpu":38,"./webgl/max_pool_backprop_gpu":39,"./webgl/max_pool_gpu":40,"./webgl/min_pool_gpu":41,"./webgl/minmax_gpu":42,"./webgl/mulmat_gpu":43,"./webgl/neg_gpu":44,"./webgl/pool_gpu":45,"./webgl/reducesum_gpu":46,"./webgl/relu_gpu":47,"./webgl/reshape_gpu":49,"./webgl/resize_bilinear_gpu":50,"./webgl/shader_compiler":51,"./webgl/sigmoid_gpu":52,"./webgl/step_gpu":53,"./webgl/texture_manager":55,"./webgl/trig_gpu":56,"./webgl/webgl_util":58}],22:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":86,"./webgl/webgl_util":58}],23:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":35}],24:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":19,"./binaryop_gpu":29}],25:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":26}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":58}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":45}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":35}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":16}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":16,"./conv_gpu":32}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":16}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":57}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":36,"./tex_util":54,"./webgl_util":58}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":54,"./webgl_util":58}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":57}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":35}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":16}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":45}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":45}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":58}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":19,"./shader_compiler":51}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":57}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":16,"./webgl_util":58}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":35}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":57}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":58}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":86}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":16}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":86}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":57}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":57}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":57}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":35}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":86}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":7,"./graph_util":10,"./ops/add":60,"./ops/argmax":61,"./ops/argmaxequals":62,"./ops/concat3d":63,"./ops/convolution":64,"./ops/divide":65,"./ops/element_wise_activation":66,"./ops/element_wise_cost":67,"./ops/exp":68,"./ops/linear_combination":69,"./ops/log":70,"./ops/matmul":71,"./ops/max_pool":72,"./ops/multiply":73,"./ops/reduce_sum":75,"./ops/reshape":76,"./ops/softmax":77,"./ops/split":78,"./ops/subtract":79}],60:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":10,"../math/ndarray":22,"../util":86,"./op":74}],61:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":74}],62:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":74}],63:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":15,"./op":74}],64:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":16,"../util":86,"./op":74}],65:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":10,"../util":86,"./op":74}],66:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":14,"./op":74}],67:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":10,"../math/cost_functions":18,"../math/ndarray":22,"../util":86,"./op":74}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":10,"./op":74}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":10,"./op":74}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":10,"./op":74}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":10,"../math/math":19,"./op":74}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":16,"../util":86,"./op":74}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":10,"../util":86,"./op":74}],74:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],75:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":10,"../math/ndarray":22,"../util":86,"./op":74}],76:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":86,"./op":74}],77:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":7,"../math/ndarray":22,"../util":86,"./op":74}],78:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":10,"../util":86,"./op":74}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":10,"../math/ndarray":22,"../util":86,"./op":74}],80:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],81:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],82:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":22,"./operation_emitter":59,"./session_util":83,"./tensor_array_map":85,"./util":86}],83:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":7,"./graph_util":10,"./math/ndarray":22,"./util":86}],84:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":22,"./optimizer":80,"./session_util":83,"./tensor_array_map":85}],85:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],86:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[1]); diff --git a/demos/homepage/index.md b/demos/homepage/index.md new file mode 100644 index 0000000000..fd0dcb89f7 --- /dev/null +++ b/demos/homepage/index.md @@ -0,0 +1,256 @@ +--- +layout: default +--- + + + + +
+
+
+

deeplearn.js is an open-source library that brings performant machine learning building blocks to the web, allowing you to train neural networks in a browser or run pre-trained models in inference mode.

+
+
+
+

We provide two APIs, an + immediate execution model (think NumPy) + and a deferred execution model + mirroring the TensorFlow API.

deeplearn.js + was originally developed by the Google Brain PAIR team to build powerful + interactive machine learning tools for the browser. You can use the library + for everything from education, to model understanding, to art projects.

+
+
+
+ +
+
+
+

Examples

+
+
+ +
+
+
+ +
+

Model Builder

+
+ +
Build a neural network in your browser, without code!
+
+ + + + + + +
+
+
+
+ +
+
+
+ +
+ Webcam Imagenet +
+ +
Squeezenet running in the browser
+
+ + + + + + +
+
+
+ +
+ NNArt +
+ +
Play with an animating CPPN
+
+ + + + + + +
+
+
+ +
+ Benchmarks +
+ +
Test the library's performance
+
+ + + + + + +
+
+
+
+
+ + +
+
+
+

Ready to Get Started?

+ {% assign default_paths = site.pages | map: "path" %} + {% assign page_paths = site.header_pages | default: default_paths %} +
    + {% for path in default_paths %} + {% assign my_page = site.pages | where: "path", path | first %} + {% assign title = my_page.title | trim %} + {% if title %} +
  • + + {{my_page.title | escape }} + +
    • + {% endif %} + {% endfor %} +
+
+
+
+ + +
+
+
+

Acknowledgements

+
+
+
+ +
+
+
+

+ deeplearn.js was originally developed by Nikhil Thorat, Daniel Smilkov and Charles Nicholson. +

+
+
+
+

+ We would like to acknowledge Chi Zeng, David Farhi, Mahima Pushkarna, + Minsuk (Brian) Kahng, James Wexler, the entire Big Picture group and + Google Brain PAIR for providing support for the project. +

+
+
+
+ diff --git a/demos/homepage/index.ts b/demos/homepage/index.ts new file mode 100644 index 0000000000..78c81d45d6 --- /dev/null +++ b/demos/homepage/index.ts @@ -0,0 +1,150 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMathGPU} from '../deeplearnjs'; +import {ActivationFunction, ColorMode, CPPN} from '../nn-art/cppn'; + +try { + const math = new NDArrayMathGPU(); + startCPPN(); +} catch (e) { + document.getElementById('disabled-demo-overlay').style.display = ''; +} + +function startCPPN() { + const MAX_Z_SCALE = 400; + const DEFAULT_Z_SCALE = 1; + const NUM_NEURONS = 30; + const DEFAULT_NUM_LAYERS = 2; + const WEIGHTS_STDEV = 0.6; + + const inferenceCanvas = + document.querySelector('#inference') as HTMLCanvasElement; + const cppn = new CPPN(inferenceCanvas); + + cppn.setActivationFunction('tanh'); + cppn.setColorMode('rgb'); + cppn.setNumLayers(DEFAULT_NUM_LAYERS); + cppn.setZ1Scale(convertZScale(DEFAULT_Z_SCALE)); + cppn.setZ2Scale(convertZScale(DEFAULT_Z_SCALE)); + cppn.generateWeights(NUM_NEURONS, WEIGHTS_STDEV); + cppn.start(); + + const currentColorElement = + document.querySelector('#colormode') as HTMLInputElement; + + document.querySelector('#color-selector')!.addEventListener( + // tslint:disable-next-line:no-any + 'click', (event: any) => { + const colorMode = + (event.target as HTMLElement).getAttribute('data-val') as ColorMode; + currentColorElement.value = colorMode; + cppn.setColorMode(colorMode); + }); + + const currentActivationFnElement = + document.querySelector('#activation-fn') as HTMLInputElement; + document.querySelector('#activation-selector')!.addEventListener( + // tslint:disable-next-line:no-any + 'click', (event: any) => { + const activationFn = + (event.target as HTMLElement).getAttribute('data-val') as + ActivationFunction; + currentActivationFnElement.value = activationFn; + cppn.setActivationFunction(activationFn); + }); + + const layersSlider = + document.querySelector('#layers-slider') as HTMLInputElement; + const layersCountElement = + document.querySelector('#layers-count') as HTMLDivElement; + layersSlider!.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + const numLayers = (event as any).target.value; + layersCountElement.innerText = '' + numLayers; + cppn.setNumLayers(numLayers); + }); + layersCountElement.innerText = '' + DEFAULT_NUM_LAYERS; + + const z1Slider = document.querySelector('#z1-slider') as HTMLInputElement; + z1Slider.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + const z1Scale = (event as any).target.value; + cppn.setZ1Scale(convertZScale(z1Scale)); + }); + + const z2Slider = document.querySelector('#z2-slider') as HTMLInputElement; + z2Slider.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + const z2Scale = (event as any).target.value; + cppn.setZ2Scale(convertZScale(z2Scale)); + }); + + const randomizeButton = + document.querySelector('#random') as HTMLButtonElement; + randomizeButton.addEventListener('click', () => { + cppn.generateWeights(NUM_NEURONS, WEIGHTS_STDEV); + if (!playing) { + cppn.start(); + requestAnimationFrame(() => { + cppn.stopInferenceLoop(); + }); + } + }); + + let playing = true; + const toggleButton = document.querySelector('#toggle') as HTMLButtonElement; + toggleButton.addEventListener('click', () => { + playing = !playing; + if (playing) { + toggleButton.innerHTML = 'STOP'; + cppn.start(); + } else { + toggleButton.innerHTML = 'START'; + cppn.stopInferenceLoop(); + } + }); + + let canvasOnScreenLast = true; + let scrollEventScheduled = false; + const mainElement = document.querySelector('main') as HTMLElement; + mainElement.addEventListener('scroll', () => { + if (!scrollEventScheduled) { + window.requestAnimationFrame(() => { + const canvasOnScreen = isCanvasOnScreen(); + if (canvasOnScreen !== canvasOnScreenLast) { + if (canvasOnScreen) { + if (playing) { + cppn.start(); + } + } else { + cppn.stopInferenceLoop(); + } + canvasOnScreenLast = canvasOnScreen; + } + scrollEventScheduled = false; + }); + } + scrollEventScheduled = true; + }); + + function isCanvasOnScreen() { + return mainElement.scrollTop < inferenceCanvas.offsetHeight; + } + + function convertZScale(z: number): number { + return (103 - z); + } +} diff --git a/demos/imagenet/bundle.js b/demos/imagenet/bundle.js new file mode 100644 index 0000000000..44332e7744 --- /dev/null +++ b/demos/imagenet/bundle.js @@ -0,0 +1,9296 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":26,"./util":90}],11:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":12,"./math/concat3d_util":19,"./math/conv_util":20,"./math/ndarray":26,"./util":90}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":16}],13:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":26,"./session":86}],14:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":11,"./priority_queue":85}],15:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":9,"./dataset":10,"./graph":11,"./graph_runner":13,"./initializers":16,"./input_provider":17,"./math/conv_util":20,"./math/math":23,"./math/math_cpu":24,"./math/math_gpu":25,"./math/ndarray":26,"./math/webgl/gpgpu_context":39,"./math/webgl/gpgpu_util":40,"./math/webgl/render_ndarray_gpu_util":52,"./math/webgl/webgl_util":62,"./optimizer":84,"./session":86,"./sgd_optimizer":88,"./util":90}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":26}],17:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":26,"./util":90}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":26}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":90}],20:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":90}],21:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],22:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":26}],23:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":90,"./concat3d_util":19,"./copy2d_util":21,"./ndarray":26}],24:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":20,"../util":90,"./concat3d_util":19,"./copy2d_util":21,"./math":23,"./ndarray":26}],25:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":90,"./concat3d_util":19,"./conv_util":20,"./math":23,"./ndarray":26,"./webgl/addscaledmat_gpu":27,"./webgl/addsubmuldiv_gpu":28,"./webgl/argmaxequals_gpu":29,"./webgl/argminmax_gpu":30,"./webgl/avg_pool_gpu":31,"./webgl/batchnorm_gpu":32,"./webgl/concat3d_gpu":34,"./webgl/conv_backprop_gpu":35,"./webgl/conv_gpu":36,"./webgl/copy_gpu":37,"./webgl/exp_gpu":38,"./webgl/gpgpu_context":39,"./webgl/gpgpu_util":40,"./webgl/log_gpu":41,"./webgl/logsumexp_gpu":42,"./webgl/max_pool_backprop_gpu":43,"./webgl/max_pool_gpu":44,"./webgl/min_pool_gpu":45,"./webgl/minmax_gpu":46,"./webgl/mulmat_gpu":47,"./webgl/neg_gpu":48,"./webgl/pool_gpu":49,"./webgl/reducesum_gpu":50,"./webgl/relu_gpu":51,"./webgl/reshape_gpu":53,"./webgl/resize_bilinear_gpu":54,"./webgl/shader_compiler":55,"./webgl/sigmoid_gpu":56,"./webgl/step_gpu":57,"./webgl/texture_manager":59,"./webgl/trig_gpu":60,"./webgl/webgl_util":62}],26:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":90,"./webgl/webgl_util":62}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":39}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":23,"./binaryop_gpu":33}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":30}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":62}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":49}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":39}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":20}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":20,"./conv_gpu":36}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":20}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":61}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":40,"./tex_util":58,"./webgl_util":62}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":58,"./webgl_util":62}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":61}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":39}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":20}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":49}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":49}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":62}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":23,"./shader_compiler":55}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":61}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":20,"./webgl_util":62}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":39}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":61}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":62}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":90}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":20}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":90}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":61}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":61}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],60:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":61}],61:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":39}],62:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":90}],63:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":11,"./graph_util":14,"./ops/add":64,"./ops/argmax":65,"./ops/argmaxequals":66,"./ops/concat3d":67,"./ops/convolution":68,"./ops/divide":69,"./ops/element_wise_activation":70,"./ops/element_wise_cost":71,"./ops/exp":72,"./ops/linear_combination":73,"./ops/log":74,"./ops/matmul":75,"./ops/max_pool":76,"./ops/multiply":77,"./ops/reduce_sum":79,"./ops/reshape":80,"./ops/softmax":81,"./ops/split":82,"./ops/subtract":83}],64:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":14,"../math/ndarray":26,"../util":90,"./op":78}],65:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":78}],66:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":78}],67:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":19,"./op":78}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":20,"../util":90,"./op":78}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":14,"../util":90,"./op":78}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":18,"./op":78}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":14,"../math/cost_functions":22,"../math/ndarray":26,"../util":90,"./op":78}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":14,"./op":78}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":14,"./op":78}],74:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":14,"./op":78}],75:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":14,"../math/math":23,"./op":78}],76:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":20,"../util":90,"./op":78}],77:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":14,"../util":90,"./op":78}],78:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":14,"../math/ndarray":26,"../util":90,"./op":78}],80:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":90,"./op":78}],81:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":11,"../math/ndarray":26,"../util":90,"./op":78}],82:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":14,"../util":90,"./op":78}],83:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":14,"../math/ndarray":26,"../util":90,"./op":78}],84:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],85:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],86:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":26,"./operation_emitter":63,"./session_util":87,"./tensor_array_map":89,"./util":90}],87:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":11,"./graph_util":14,"./math/ndarray":26,"./util":90}],88:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":26,"./optimizer":84,"./session_util":87,"./tensor_array_map":89}],89:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],90:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[3]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","demos/demo-footer.ts","demos/demo-header.ts","demos/imagenet/imagenet-demo.ts","demos/learnjs.ts","demos/models/imagenet_classes.ts","demos/models/imagenet_util.ts","demos/models/squeezenet.ts","demos/polymer-spec.ts","src/checkpoint_loader.ts","src/dataset.ts","src/graph.ts","src/graph_layers.ts","src/graph_runner.ts","src/graph_util.ts","src/index.ts","src/initializers.ts","src/input_provider.ts","src/math/activation_functions.ts","src/math/concat3d_util.ts","src/math/conv_util.ts","src/math/copy2d_util.ts","src/math/cost_functions.ts","src/math/math.ts","src/math/math_cpu.ts","src/math/math_gpu.ts","src/math/ndarray.ts","src/math/webgl/addscaledmat_gpu.ts","src/math/webgl/addsubmuldiv_gpu.ts","src/math/webgl/argmaxequals_gpu.ts","src/math/webgl/argminmax_gpu.ts","src/math/webgl/avg_pool_gpu.ts","src/math/webgl/batchnorm_gpu.ts","src/math/webgl/binaryop_gpu.ts","src/math/webgl/concat3d_gpu.ts","src/math/webgl/conv_backprop_gpu.ts","src/math/webgl/conv_gpu.ts","src/math/webgl/copy_gpu.ts","src/math/webgl/exp_gpu.ts","src/math/webgl/gpgpu_context.ts","src/math/webgl/gpgpu_util.ts","src/math/webgl/log_gpu.ts","src/math/webgl/logsumexp_gpu.ts","src/math/webgl/max_pool_backprop_gpu.ts","src/math/webgl/max_pool_gpu.ts","src/math/webgl/min_pool_gpu.ts","src/math/webgl/minmax_gpu.ts","src/math/webgl/mulmat_gpu.ts","src/math/webgl/neg_gpu.ts","src/math/webgl/pool_gpu.ts","src/math/webgl/reducesum_gpu.ts","src/math/webgl/relu_gpu.ts","src/math/webgl/render_ndarray_gpu_util.ts","src/math/webgl/reshape_gpu.ts","src/math/webgl/resize_bilinear_gpu.ts","src/math/webgl/shader_compiler.ts","src/math/webgl/sigmoid_gpu.ts","src/math/webgl/step_gpu.ts","src/math/webgl/tex_util.ts","src/math/webgl/texture_manager.ts","src/math/webgl/trig_gpu.ts","src/math/webgl/unaryop_gpu.ts","src/math/webgl/webgl_util.ts","src/operation_emitter.ts","src/ops/add.ts","src/ops/argmax.ts","src/ops/argmaxequals.ts","src/ops/concat3d.ts","src/ops/convolution.ts","src/ops/divide.ts","src/ops/element_wise_activation.ts","src/ops/element_wise_cost.ts","src/ops/exp.ts","src/ops/linear_combination.ts","src/ops/log.ts","src/ops/matmul.ts","src/ops/max_pool.ts","src/ops/multiply.ts","src/ops/op.ts","src/ops/reduce_sum.ts","src/ops/reshape.ts","src/ops/softmax.ts","src/ops/split.ts","src/ops/subtract.ts","src/optimizer.ts","src/priority_queue.ts","src/session.ts","src/session_util.ts","src/sgd_optimizer.ts","src/tensor_array_map.ts","src/util.ts"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-footer'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-header'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport '../demo-header';\nimport '../demo-footer';\nimport {Array3D, gpgpu_util, GPGPUContext, NDArray, NDArrayMathCPU, NDArrayMathGPU} from '../learnjs';\nimport * as imagenet_classes from '../models/imagenet_classes';\nimport * as imagenet_util from '../models/imagenet_util';\nimport {SqueezeNet} from '../models/squeezenet';\n// tslint:disable-next-line:no-unused-variable\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\n\n// tslint:disable-next-line:variable-name\nexport const ImagenetDemoPolymer = PolymerElement({\n  is: 'imagenet-demo',\n  properties: {\n    layerNames: Array,\n    selectedLayerName: String,\n    inputNames: Array,\n    selectedInputName: String\n  }\n});\n\n/**\n * NOTE: To use the webcam without SSL, use the chrome flag:\n * --unsafely-treat-insecure-origin-as-secure=\\\n *     http://localhost:5432\n */\n\nconst NUM_CLASSES = 1000;\nconst IMAGE_SIZE = 227;\nconst TOP_K_CLASSES = 5;\n\nconst INPUT_NAMES = ['cat', 'dog1', 'dog2', 'beerbottle', 'piano', 'saxophone'];\nexport class ImagenetDemo extends ImagenetDemoPolymer {\n  private variables: {[varName: string]: NDArray};\n\n  private math: NDArrayMathGPU;\n  private mathCPU: NDArrayMathCPU;\n  private gl: WebGLRenderingContext;\n  private gpgpu: GPGPUContext;\n  private renderGrayscaleChannelsCollageShader: WebGLShader;\n\n  private squeezeNet: SqueezeNet;\n\n  private webcamVideoElement: HTMLVideoElement;\n  private staticImgElement: HTMLImageElement;\n\n  private layerNames: string[];\n  private selectedLayerName: string;\n  private inputNames: string[];\n  private selectedInputName: string;\n\n  private inferenceCanvas: HTMLCanvasElement;\n\n  ready() {\n    this.inferenceCanvas =\n        this.querySelector('#inference-canvas') as HTMLCanvasElement;\n    this.staticImgElement =\n        this.querySelector('#staticImg') as HTMLImageElement;\n    this.webcamVideoElement =\n        this.querySelector('#webcamVideo') as HTMLVideoElement;\n\n    this.layerNames = [];\n    this.selectedLayerName = 'conv_1';\n\n    const inputDropdown = this.querySelector('#input-dropdown')!;\n    // tslint:disable-next-line:no-any\n    inputDropdown.addEventListener('iron-activate', (event: any) => {\n      const selectedInputName = event.detail.selected;\n      if (selectedInputName === 'webcam') {\n        this.webcamVideoElement.style.display = '';\n        this.staticImgElement.style.display = 'none';\n      } else {\n        this.webcamVideoElement.style.display = 'none';\n        this.staticImgElement.style.display = '';\n      }\n      this.staticImgElement.src = 'images/' + event.detail.selected + '.jpg';\n    });\n\n    if (navigator.getUserMedia) {\n      navigator.getUserMedia(\n          {video: true},\n          (stream) => {\n            this.webcamVideoElement.src = window.URL.createObjectURL(stream);\n            this.initWithWebcam();\n          },\n          (error) => {\n            console.log(error);\n            this.initWithoutWebcam();\n          });\n    } else {\n      this.initWithoutWebcam();\n    }\n\n    this.gl = gpgpu_util.createWebGLContext(this.inferenceCanvas);\n    this.gpgpu = new GPGPUContext(this.gl);\n    this.math = new NDArrayMathGPU(this.gpgpu);\n    this.mathCPU = new NDArrayMathCPU();\n\n    this.squeezeNet = new SqueezeNet(this.gpgpu, this.math);\n    this.squeezeNet.loadVariables().then(() => {\n      requestAnimationFrame(() => this.animate());\n    });\n\n    this.renderGrayscaleChannelsCollageShader =\n        imagenet_util.getRenderGrayscaleChannelsCollageShader(this.gpgpu);\n  }\n\n  private initWithoutWebcam() {\n    this.inputNames = INPUT_NAMES;\n    this.selectedInputName = 'cat';\n    this.staticImgElement.src = 'images/cat.jpg';\n    this.webcamVideoElement.style.display = 'none';\n    this.staticImgElement.style.display = '';\n\n    if (location.protocol !== 'https:') {\n      (this.querySelector('#ssl-message') as HTMLElement).style.display =\n          'block';\n    }\n\n    (this.querySelector('#webcam-message') as HTMLElement).style.display =\n        'block';\n  }\n\n  private initWithWebcam() {\n    const inputNames = INPUT_NAMES.slice();\n    inputNames.unshift('webcam');\n    this.inputNames = inputNames;\n    this.selectedInputName = 'webcam';\n  }\n\n  private animate() {\n    const startTime = performance.now();\n\n    const isWebcam = this.selectedInputName === 'webcam';\n\n    const canvasTextureShape: [number, number] = [IMAGE_SIZE, IMAGE_SIZE];\n    const canvasTexture =\n        this.math.getTextureManager().acquireTexture(canvasTextureShape);\n\n    const element = isWebcam ? this.webcamVideoElement : this.staticImgElement;\n    this.gpgpu.uploadPixelDataToTexture(canvasTexture, element);\n\n    this.math.scope((keep, track) => {\n      const preprocessedInput =\n          track(this.squeezeNet.preprocessColorTextureToArray3D(\n              canvasTexture, canvasTextureShape));\n\n      const inferenceResult = this.squeezeNet.infer(preprocessedInput);\n      const namedActivations = inferenceResult.namedActivations;\n\n      this.layerNames = Object.keys(namedActivations);\n      this.layerNames.forEach(layerName => track(namedActivations[layerName]));\n\n      const topClassesToProbability =\n          this.squeezeNet.getTopKClasses(inferenceResult.logits, TOP_K_CLASSES);\n\n      let count = 0;\n      for (const className in topClassesToProbability) {\n        if (!(className in topClassesToProbability)) {\n          continue;\n        }\n        document.getElementById('class' + count)!.innerHTML = className;\n        document.getElementById('prob' + count)!.innerHTML =\n            '' + Math.floor(1000 * topClassesToProbability[className]) / 1000;\n        count++;\n      }\n\n      const endTime = performance.now();\n\n      (this.querySelector('#totalTime') as HTMLDivElement).innerHTML =\n          'last inference time: ' +\n          Math.floor(1000 * (endTime - startTime)) / 1000 + 'ms';\n\n      // Render activations.\n      const activationNDArray = namedActivations[this.selectedLayerName];\n\n      // Compute max and min per channel for normalization.\n      const maxValues = this.math.maxPool(\n          activationNDArray, activationNDArray.shape[1],\n          activationNDArray.shape[1], 0);\n      const minValues = this.math.minPool(\n          activationNDArray, activationNDArray.shape[1],\n          activationNDArray.shape[1], 0);\n\n      // Logically resize the rendering canvas. The displayed width is fixed.\n      const imagesPerRow = Math.ceil(Math.sqrt(activationNDArray.shape[2]));\n      const numRows = Math.ceil(activationNDArray.shape[2] / imagesPerRow);\n      this.inferenceCanvas.width = imagesPerRow * activationNDArray.shape[0];\n      this.inferenceCanvas.height = numRows * activationNDArray.shape[0];\n\n      imagenet_util.renderGrayscaleChannelsCollage(\n          this.gpgpu, this.renderGrayscaleChannelsCollageShader,\n          activationNDArray.getTexture(), minValues.getTexture(),\n          maxValues.getTexture(), activationNDArray.getTextureShapeRC(),\n          activationNDArray.shape[0], activationNDArray.shape[2],\n          this.inferenceCanvas.width, numRows);\n    });\n\n    this.math.getTextureManager().releaseTexture(\n        canvasTexture, canvasTextureShape);\n\n    requestAnimationFrame(() => this.animate());\n  }\n}\n\ndocument.registerElement(ImagenetDemo.prototype.is, ImagenetDemo);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// This file is just an alias that points to the current learnjs version\n// at this branch, so demos can import the library as '../learnjs'.\nexport * from '../src/index';\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport const IMAGENET_CLASSES: {[key: number]: string} = {\n  0: 'tench, Tinca tinca',\n  1: 'goldfish, Carassius auratus',\n  2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias',\n  3: 'tiger shark, Galeocerdo cuvieri',\n  4: 'hammerhead, hammerhead shark',\n  5: 'electric ray, crampfish, numbfish, torpedo',\n  6: 'stingray',\n  7: 'cock',\n  8: 'hen',\n  9: 'ostrich, Struthio camelus',\n  10: 'brambling, Fringilla montifringilla',\n  11: 'goldfinch, Carduelis carduelis',\n  12: 'house finch, linnet, Carpodacus mexicanus',\n  13: 'junco, snowbird',\n  14: 'indigo bunting, indigo finch, indigo bird, Passerina cyanea',\n  15: 'robin, American robin, Turdus migratorius',\n  16: 'bulbul',\n  17: 'jay',\n  18: 'magpie',\n  19: 'chickadee',\n  20: 'water ouzel, dipper',\n  21: 'kite',\n  22: 'bald eagle, American eagle, Haliaeetus leucocephalus',\n  23: 'vulture',\n  24: 'great grey owl, great gray owl, Strix nebulosa',\n  25: 'European fire salamander, Salamandra salamandra',\n  26: 'common newt, Triturus vulgaris',\n  27: 'eft',\n  28: 'spotted salamander, Ambystoma maculatum',\n  29: 'axolotl, mud puppy, Ambystoma mexicanum',\n  30: 'bullfrog, Rana catesbeiana',\n  31: 'tree frog, tree-frog',\n  32: 'tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui',\n  33: 'loggerhead, loggerhead turtle, Caretta caretta',\n  34: 'leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea',\n  35: 'mud turtle',\n  36: 'terrapin',\n  37: 'box turtle, box tortoise',\n  38: 'banded gecko',\n  39: 'common iguana, iguana, Iguana iguana',\n  40: 'American chameleon, anole, Anolis carolinensis',\n  41: 'whiptail, whiptail lizard',\n  42: 'agama',\n  43: 'frilled lizard, Chlamydosaurus kingi',\n  44: 'alligator lizard',\n  45: 'Gila monster, Heloderma suspectum',\n  46: 'green lizard, Lacerta viridis',\n  47: 'African chameleon, Chamaeleo chamaeleon',\n  48: 'Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis',\n  49: 'African crocodile, Nile crocodile, Crocodylus niloticus',\n  50: 'American alligator, Alligator mississipiensis',\n  51: 'triceratops',\n  52: 'thunder snake, worm snake, Carphophis amoenus',\n  53: 'ringneck snake, ring-necked snake, ring snake',\n  54: 'hognose snake, puff adder, sand viper',\n  55: 'green snake, grass snake',\n  56: 'king snake, kingsnake',\n  57: 'garter snake, grass snake',\n  58: 'water snake',\n  59: 'vine snake',\n  60: 'night snake, Hypsiglena torquata',\n  61: 'boa constrictor, Constrictor constrictor',\n  62: 'rock python, rock snake, Python sebae',\n  63: 'Indian cobra, Naja naja',\n  64: 'green mamba',\n  65: 'sea snake',\n  66: 'horned viper, cerastes, sand viper, horned asp, Cerastes cornutus',\n  67: 'diamondback, diamondback rattlesnake, Crotalus adamanteus',\n  68: 'sidewinder, horned rattlesnake, Crotalus cerastes',\n  69: 'trilobite',\n  70: 'harvestman, daddy longlegs, Phalangium opilio',\n  71: 'scorpion',\n  72: 'black and gold garden spider, Argiope aurantia',\n  73: 'barn spider, Araneus cavaticus',\n  74: 'garden spider, Aranea diademata',\n  75: 'black widow, Latrodectus mactans',\n  76: 'tarantula',\n  77: 'wolf spider, hunting spider',\n  78: 'tick',\n  79: 'centipede',\n  80: 'black grouse',\n  81: 'ptarmigan',\n  82: 'ruffed grouse, partridge, Bonasa umbellus',\n  83: 'prairie chicken, prairie grouse, prairie fowl',\n  84: 'peacock',\n  85: 'quail',\n  86: 'partridge',\n  87: 'African grey, African gray, Psittacus erithacus',\n  88: 'macaw',\n  89: 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita',\n  90: 'lorikeet',\n  91: 'coucal',\n  92: 'bee eater',\n  93: 'hornbill',\n  94: 'hummingbird',\n  95: 'jacamar',\n  96: 'toucan',\n  97: 'drake',\n  98: 'red-breasted merganser, Mergus serrator',\n  99: 'goose',\n  100: 'black swan, Cygnus atratus',\n  101: 'tusker',\n  102: 'echidna, spiny anteater, anteater',\n  103:\n      'platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus',\n  104: 'wallaby, brush kangaroo',\n  105: 'koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus',\n  106: 'wombat',\n  107: 'jelly fish',\n  108: 'sea anemone, anemone',\n  109: 'brain coral',\n  110: 'flatworm, platyhelminth',\n  111: 'nematode, nematode worm, roundworm',\n  112: 'conch',\n  113: 'snail',\n  114: 'slug',\n  115: 'sea slug, nudibranch',\n  116: 'chiton, coat-of-mail shell, sea cradle, polyplacophore',\n  117: 'chambered nautilus, pearly nautilus, nautilus',\n  118: 'Dungeness crab, Cancer magister',\n  119: 'rock crab, Cancer irroratus',\n  120: 'fiddler crab',\n  121:\n      'king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica',\n  122: 'American lobster, Northern lobster, Maine lobster, Homarus americanus',\n  123:\n      'spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish',\n  124: 'crayfish, crawfish, crawdad, crawdaddy',\n  125: 'hermit crab',\n  126: 'isopod',\n  127: 'white stork, Ciconia ciconia',\n  128: 'black stork, Ciconia nigra',\n  129: 'spoonbill',\n  130: 'flamingo',\n  131: 'little blue heron, Egretta caerulea',\n  132: 'American egret, great white heron, Egretta albus',\n  133: 'bittern',\n  134: 'crane',\n  135: 'limpkin, Aramus pictus',\n  136: 'European gallinule, Porphyrio porphyrio',\n  137: 'American coot, marsh hen, mud hen, water hen, Fulica americana',\n  138: 'bustard',\n  139: 'ruddy turnstone, Arenaria interpres',\n  140: 'red-backed sandpiper, dunlin, Erolia alpina',\n  141: 'redshank, Tringa totanus',\n  142: 'dowitcher',\n  143: 'oystercatcher, oyster catcher',\n  144: 'pelican',\n  145: 'king penguin, Aptenodytes patagonica',\n  146: 'albatross, mollymawk',\n  147:\n      'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus',\n  148: 'killer whale, killer, orca, grampus, sea wolf, Orcinus orca',\n  149: 'dugong, Dugong dugon',\n  150: 'sea lion',\n  151: 'Chihuahua',\n  152: 'Japanese spaniel',\n  153: 'Maltese dog, Maltese terrier, Maltese',\n  154: 'Pekinese, Pekingese, Peke',\n  155: 'Shih-Tzu',\n  156: 'Blenheim spaniel',\n  157: 'papillon',\n  158: 'toy terrier',\n  159: 'Rhodesian ridgeback',\n  160: 'Afghan hound, Afghan',\n  161: 'basset, basset hound',\n  162: 'beagle',\n  163: 'bloodhound, sleuthhound',\n  164: 'bluetick',\n  165: 'black-and-tan coonhound',\n  166: 'Walker hound, Walker foxhound',\n  167: 'English foxhound',\n  168: 'redbone',\n  169: 'borzoi, Russian wolfhound',\n  170: 'Irish wolfhound',\n  171: 'Italian greyhound',\n  172: 'whippet',\n  173: 'Ibizan hound, Ibizan Podenco',\n  174: 'Norwegian elkhound, elkhound',\n  175: 'otterhound, otter hound',\n  176: 'Saluki, gazelle hound',\n  177: 'Scottish deerhound, deerhound',\n  178: 'Weimaraner',\n  179: 'Staffordshire bullterrier, Staffordshire bull terrier',\n  180:\n      'American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier',\n  181: 'Bedlington terrier',\n  182: 'Border terrier',\n  183: 'Kerry blue terrier',\n  184: 'Irish terrier',\n  185: 'Norfolk terrier',\n  186: 'Norwich terrier',\n  187: 'Yorkshire terrier',\n  188: 'wire-haired fox terrier',\n  189: 'Lakeland terrier',\n  190: 'Sealyham terrier, Sealyham',\n  191: 'Airedale, Airedale terrier',\n  192: 'cairn, cairn terrier',\n  193: 'Australian terrier',\n  194: 'Dandie Dinmont, Dandie Dinmont terrier',\n  195: 'Boston bull, Boston terrier',\n  196: 'miniature schnauzer',\n  197: 'giant schnauzer',\n  198: 'standard schnauzer',\n  199: 'Scotch terrier, Scottish terrier, Scottie',\n  200: 'Tibetan terrier, chrysanthemum dog',\n  201: 'silky terrier, Sydney silky',\n  202: 'soft-coated wheaten terrier',\n  203: 'West Highland white terrier',\n  204: 'Lhasa, Lhasa apso',\n  205: 'flat-coated retriever',\n  206: 'curly-coated retriever',\n  207: 'golden retriever',\n  208: 'Labrador retriever',\n  209: 'Chesapeake Bay retriever',\n  210: 'German short-haired pointer',\n  211: 'vizsla, Hungarian pointer',\n  212: 'English setter',\n  213: 'Irish setter, red setter',\n  214: 'Gordon setter',\n  215: 'Brittany spaniel',\n  216: 'clumber, clumber spaniel',\n  217: 'English springer, English springer spaniel',\n  218: 'Welsh springer spaniel',\n  219: 'cocker spaniel, English cocker spaniel, cocker',\n  220: 'Sussex spaniel',\n  221: 'Irish water spaniel',\n  222: 'kuvasz',\n  223: 'schipperke',\n  224: 'groenendael',\n  225: 'malinois',\n  226: 'briard',\n  227: 'kelpie',\n  228: 'komondor',\n  229: 'Old English sheepdog, bobtail',\n  230: 'Shetland sheepdog, Shetland sheep dog, Shetland',\n  231: 'collie',\n  232: 'Border collie',\n  233: 'Bouvier des Flandres, Bouviers des Flandres',\n  234: 'Rottweiler',\n  235: 'German shepherd, German shepherd dog, German police dog, alsatian',\n  236: 'Doberman, Doberman pinscher',\n  237: 'miniature pinscher',\n  238: 'Greater Swiss Mountain dog',\n  239: 'Bernese mountain dog',\n  240: 'Appenzeller',\n  241: 'EntleBucher',\n  242: 'boxer',\n  243: 'bull mastiff',\n  244: 'Tibetan mastiff',\n  245: 'French bulldog',\n  246: 'Great Dane',\n  247: 'Saint Bernard, St Bernard',\n  248: 'Eskimo dog, husky',\n  249: 'malamute, malemute, Alaskan malamute',\n  250: 'Siberian husky',\n  251: 'dalmatian, coach dog, carriage dog',\n  252: 'affenpinscher, monkey pinscher, monkey dog',\n  253: 'basenji',\n  254: 'pug, pug-dog',\n  255: 'Leonberg',\n  256: 'Newfoundland, Newfoundland dog',\n  257: 'Great Pyrenees',\n  258: 'Samoyed, Samoyede',\n  259: 'Pomeranian',\n  260: 'chow, chow chow',\n  261: 'keeshond',\n  262: 'Brabancon griffon',\n  263: 'Pembroke, Pembroke Welsh corgi',\n  264: 'Cardigan, Cardigan Welsh corgi',\n  265: 'toy poodle',\n  266: 'miniature poodle',\n  267: 'standard poodle',\n  268: 'Mexican hairless',\n  269: 'timber wolf, grey wolf, gray wolf, Canis lupus',\n  270: 'white wolf, Arctic wolf, Canis lupus tundrarum',\n  271: 'red wolf, maned wolf, Canis rufus, Canis niger',\n  272: 'coyote, prairie wolf, brush wolf, Canis latrans',\n  273: 'dingo, warrigal, warragal, Canis dingo',\n  274: 'dhole, Cuon alpinus',\n  275: 'African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus',\n  276: 'hyena, hyaena',\n  277: 'red fox, Vulpes vulpes',\n  278: 'kit fox, Vulpes macrotis',\n  279: 'Arctic fox, white fox, Alopex lagopus',\n  280: 'grey fox, gray fox, Urocyon cinereoargenteus',\n  281: 'tabby, tabby cat',\n  282: 'tiger cat',\n  283: 'Persian cat',\n  284: 'Siamese cat, Siamese',\n  285: 'Egyptian cat',\n  286:\n      'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor',\n  287: 'lynx, catamount',\n  288: 'leopard, Panthera pardus',\n  289: 'snow leopard, ounce, Panthera uncia',\n  290: 'jaguar, panther, Panthera onca, Felis onca',\n  291: 'lion, king of beasts, Panthera leo',\n  292: 'tiger, Panthera tigris',\n  293: 'cheetah, chetah, Acinonyx jubatus',\n  294: 'brown bear, bruin, Ursus arctos',\n  295: 'American black bear, black bear, Ursus americanus, Euarctos americanus',\n  296: 'ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus',\n  297: 'sloth bear, Melursus ursinus, Ursus ursinus',\n  298: 'mongoose',\n  299: 'meerkat, mierkat',\n  300: 'tiger beetle',\n  301: 'ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle',\n  302: 'ground beetle, carabid beetle',\n  303: 'long-horned beetle, longicorn, longicorn beetle',\n  304: 'leaf beetle, chrysomelid',\n  305: 'dung beetle',\n  306: 'rhinoceros beetle',\n  307: 'weevil',\n  308: 'fly',\n  309: 'bee',\n  310: 'ant, emmet, pismire',\n  311: 'grasshopper, hopper',\n  312: 'cricket',\n  313: 'walking stick, walkingstick, stick insect',\n  314: 'cockroach, roach',\n  315: 'mantis, mantid',\n  316: 'cicada, cicala',\n  317: 'leafhopper',\n  318: 'lacewing, lacewing fly',\n  319:\n      'dragonfly, darning needle, devil\\'s darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk',\n  320: 'damselfly',\n  321: 'admiral',\n  322: 'ringlet, ringlet butterfly',\n  323: 'monarch, monarch butterfly, milkweed butterfly, Danaus plexippus',\n  324: 'cabbage butterfly',\n  325: 'sulphur butterfly, sulfur butterfly',\n  326: 'lycaenid, lycaenid butterfly',\n  327: 'starfish, sea star',\n  328: 'sea urchin',\n  329: 'sea cucumber, holothurian',\n  330: 'wood rabbit, cottontail, cottontail rabbit',\n  331: 'hare',\n  332: 'Angora, Angora rabbit',\n  333: 'hamster',\n  334: 'porcupine, hedgehog',\n  335: 'fox squirrel, eastern fox squirrel, Sciurus niger',\n  336: 'marmot',\n  337: 'beaver',\n  338: 'guinea pig, Cavia cobaya',\n  339: 'sorrel',\n  340: 'zebra',\n  341: 'hog, pig, grunter, squealer, Sus scrofa',\n  342: 'wild boar, boar, Sus scrofa',\n  343: 'warthog',\n  344: 'hippopotamus, hippo, river horse, Hippopotamus amphibius',\n  345: 'ox',\n  346: 'water buffalo, water ox, Asiatic buffalo, Bubalus bubalis',\n  347: 'bison',\n  348: 'ram, tup',\n  349:\n      'bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis',\n  350: 'ibex, Capra ibex',\n  351: 'hartebeest',\n  352: 'impala, Aepyceros melampus',\n  353: 'gazelle',\n  354: 'Arabian camel, dromedary, Camelus dromedarius',\n  355: 'llama',\n  356: 'weasel',\n  357: 'mink',\n  358: 'polecat, fitch, foulmart, foumart, Mustela putorius',\n  359: 'black-footed ferret, ferret, Mustela nigripes',\n  360: 'otter',\n  361: 'skunk, polecat, wood pussy',\n  362: 'badger',\n  363: 'armadillo',\n  364: 'three-toed sloth, ai, Bradypus tridactylus',\n  365: 'orangutan, orang, orangutang, Pongo pygmaeus',\n  366: 'gorilla, Gorilla gorilla',\n  367: 'chimpanzee, chimp, Pan troglodytes',\n  368: 'gibbon, Hylobates lar',\n  369: 'siamang, Hylobates syndactylus, Symphalangus syndactylus',\n  370: 'guenon, guenon monkey',\n  371: 'patas, hussar monkey, Erythrocebus patas',\n  372: 'baboon',\n  373: 'macaque',\n  374: 'langur',\n  375: 'colobus, colobus monkey',\n  376: 'proboscis monkey, Nasalis larvatus',\n  377: 'marmoset',\n  378: 'capuchin, ringtail, Cebus capucinus',\n  379: 'howler monkey, howler',\n  380: 'titi, titi monkey',\n  381: 'spider monkey, Ateles geoffroyi',\n  382: 'squirrel monkey, Saimiri sciureus',\n  383: 'Madagascar cat, ring-tailed lemur, Lemur catta',\n  384: 'indri, indris, Indri indri, Indri brevicaudatus',\n  385: 'Indian elephant, Elephas maximus',\n  386: 'African elephant, Loxodonta africana',\n  387: 'lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens',\n  388: 'giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca',\n  389: 'barracouta, snoek',\n  390: 'eel',\n  391:\n      'coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch',\n  392: 'rock beauty, Holocanthus tricolor',\n  393: 'anemone fish',\n  394: 'sturgeon',\n  395: 'gar, garfish, garpike, billfish, Lepisosteus osseus',\n  396: 'lionfish',\n  397: 'puffer, pufferfish, blowfish, globefish',\n  398: 'abacus',\n  399: 'abaya',\n  400: 'academic gown, academic robe, judge\\'s robe',\n  401: 'accordion, piano accordion, squeeze box',\n  402: 'acoustic guitar',\n  403: 'aircraft carrier, carrier, flattop, attack aircraft carrier',\n  404: 'airliner',\n  405: 'airship, dirigible',\n  406: 'altar',\n  407: 'ambulance',\n  408: 'amphibian, amphibious vehicle',\n  409: 'analog clock',\n  410: 'apiary, bee house',\n  411: 'apron',\n  412:\n      'ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin',\n  413: 'assault rifle, assault gun',\n  414: 'backpack, back pack, knapsack, packsack, rucksack, haversack',\n  415: 'bakery, bakeshop, bakehouse',\n  416: 'balance beam, beam',\n  417: 'balloon',\n  418: 'ballpoint, ballpoint pen, ballpen, Biro',\n  419: 'Band Aid',\n  420: 'banjo',\n  421: 'bannister, banister, balustrade, balusters, handrail',\n  422: 'barbell',\n  423: 'barber chair',\n  424: 'barbershop',\n  425: 'barn',\n  426: 'barometer',\n  427: 'barrel, cask',\n  428: 'barrow, garden cart, lawn cart, wheelbarrow',\n  429: 'baseball',\n  430: 'basketball',\n  431: 'bassinet',\n  432: 'bassoon',\n  433: 'bathing cap, swimming cap',\n  434: 'bath towel',\n  435: 'bathtub, bathing tub, bath, tub',\n  436:\n      'beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon',\n  437: 'beacon, lighthouse, beacon light, pharos',\n  438: 'beaker',\n  439: 'bearskin, busby, shako',\n  440: 'beer bottle',\n  441: 'beer glass',\n  442: 'bell cote, bell cot',\n  443: 'bib',\n  444: 'bicycle-built-for-two, tandem bicycle, tandem',\n  445: 'bikini, two-piece',\n  446: 'binder, ring-binder',\n  447: 'binoculars, field glasses, opera glasses',\n  448: 'birdhouse',\n  449: 'boathouse',\n  450: 'bobsled, bobsleigh, bob',\n  451: 'bolo tie, bolo, bola tie, bola',\n  452: 'bonnet, poke bonnet',\n  453: 'bookcase',\n  454: 'bookshop, bookstore, bookstall',\n  455: 'bottlecap',\n  456: 'bow',\n  457: 'bow tie, bow-tie, bowtie',\n  458: 'brass, memorial tablet, plaque',\n  459: 'brassiere, bra, bandeau',\n  460: 'breakwater, groin, groyne, mole, bulwark, seawall, jetty',\n  461: 'breastplate, aegis, egis',\n  462: 'broom',\n  463: 'bucket, pail',\n  464: 'buckle',\n  465: 'bulletproof vest',\n  466: 'bullet train, bullet',\n  467: 'butcher shop, meat market',\n  468: 'cab, hack, taxi, taxicab',\n  469: 'caldron, cauldron',\n  470: 'candle, taper, wax light',\n  471: 'cannon',\n  472: 'canoe',\n  473: 'can opener, tin opener',\n  474: 'cardigan',\n  475: 'car mirror',\n  476: 'carousel, carrousel, merry-go-round, roundabout, whirligig',\n  477: 'carpenter\\'s kit, tool kit',\n  478: 'carton',\n  479: 'car wheel',\n  480:\n      'cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM',\n  481: 'cassette',\n  482: 'cassette player',\n  483: 'castle',\n  484: 'catamaran',\n  485: 'CD player',\n  486: 'cello, violoncello',\n  487: 'cellular telephone, cellular phone, cellphone, cell, mobile phone',\n  488: 'chain',\n  489: 'chainlink fence',\n  490:\n      'chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour',\n  491: 'chain saw, chainsaw',\n  492: 'chest',\n  493: 'chiffonier, commode',\n  494: 'chime, bell, gong',\n  495: 'china cabinet, china closet',\n  496: 'Christmas stocking',\n  497: 'church, church building',\n  498: 'cinema, movie theater, movie theatre, movie house, picture palace',\n  499: 'cleaver, meat cleaver, chopper',\n  500: 'cliff dwelling',\n  501: 'cloak',\n  502: 'clog, geta, patten, sabot',\n  503: 'cocktail shaker',\n  504: 'coffee mug',\n  505: 'coffeepot',\n  506: 'coil, spiral, volute, whorl, helix',\n  507: 'combination lock',\n  508: 'computer keyboard, keypad',\n  509: 'confectionery, confectionary, candy store',\n  510: 'container ship, containership, container vessel',\n  511: 'convertible',\n  512: 'corkscrew, bottle screw',\n  513: 'cornet, horn, trumpet, trump',\n  514: 'cowboy boot',\n  515: 'cowboy hat, ten-gallon hat',\n  516: 'cradle',\n  517: 'crane',\n  518: 'crash helmet',\n  519: 'crate',\n  520: 'crib, cot',\n  521: 'Crock Pot',\n  522: 'croquet ball',\n  523: 'crutch',\n  524: 'cuirass',\n  525: 'dam, dike, dyke',\n  526: 'desk',\n  527: 'desktop computer',\n  528: 'dial telephone, dial phone',\n  529: 'diaper, nappy, napkin',\n  530: 'digital clock',\n  531: 'digital watch',\n  532: 'dining table, board',\n  533: 'dishrag, dishcloth',\n  534: 'dishwasher, dish washer, dishwashing machine',\n  535: 'disk brake, disc brake',\n  536: 'dock, dockage, docking facility',\n  537: 'dogsled, dog sled, dog sleigh',\n  538: 'dome',\n  539: 'doormat, welcome mat',\n  540: 'drilling platform, offshore rig',\n  541: 'drum, membranophone, tympan',\n  542: 'drumstick',\n  543: 'dumbbell',\n  544: 'Dutch oven',\n  545: 'electric fan, blower',\n  546: 'electric guitar',\n  547: 'electric locomotive',\n  548: 'entertainment center',\n  549: 'envelope',\n  550: 'espresso maker',\n  551: 'face powder',\n  552: 'feather boa, boa',\n  553: 'file, file cabinet, filing cabinet',\n  554: 'fireboat',\n  555: 'fire engine, fire truck',\n  556: 'fire screen, fireguard',\n  557: 'flagpole, flagstaff',\n  558: 'flute, transverse flute',\n  559: 'folding chair',\n  560: 'football helmet',\n  561: 'forklift',\n  562: 'fountain',\n  563: 'fountain pen',\n  564: 'four-poster',\n  565: 'freight car',\n  566: 'French horn, horn',\n  567: 'frying pan, frypan, skillet',\n  568: 'fur coat',\n  569: 'garbage truck, dustcart',\n  570: 'gasmask, respirator, gas helmet',\n  571: 'gas pump, gasoline pump, petrol pump, island dispenser',\n  572: 'goblet',\n  573: 'go-kart',\n  574: 'golf ball',\n  575: 'golfcart, golf cart',\n  576: 'gondola',\n  577: 'gong, tam-tam',\n  578: 'gown',\n  579: 'grand piano, grand',\n  580: 'greenhouse, nursery, glasshouse',\n  581: 'grille, radiator grille',\n  582: 'grocery store, grocery, food market, market',\n  583: 'guillotine',\n  584: 'hair slide',\n  585: 'hair spray',\n  586: 'half track',\n  587: 'hammer',\n  588: 'hamper',\n  589: 'hand blower, blow dryer, blow drier, hair dryer, hair drier',\n  590: 'hand-held computer, hand-held microcomputer',\n  591: 'handkerchief, hankie, hanky, hankey',\n  592: 'hard disc, hard disk, fixed disk',\n  593: 'harmonica, mouth organ, harp, mouth harp',\n  594: 'harp',\n  595: 'harvester, reaper',\n  596: 'hatchet',\n  597: 'holster',\n  598: 'home theater, home theatre',\n  599: 'honeycomb',\n  600: 'hook, claw',\n  601: 'hoopskirt, crinoline',\n  602: 'horizontal bar, high bar',\n  603: 'horse cart, horse-cart',\n  604: 'hourglass',\n  605: 'iPod',\n  606: 'iron, smoothing iron',\n  607: 'jack-o\\'-lantern',\n  608: 'jean, blue jean, denim',\n  609: 'jeep, landrover',\n  610: 'jersey, T-shirt, tee shirt',\n  611: 'jigsaw puzzle',\n  612: 'jinrikisha, ricksha, rickshaw',\n  613: 'joystick',\n  614: 'kimono',\n  615: 'knee pad',\n  616: 'knot',\n  617: 'lab coat, laboratory coat',\n  618: 'ladle',\n  619: 'lampshade, lamp shade',\n  620: 'laptop, laptop computer',\n  621: 'lawn mower, mower',\n  622: 'lens cap, lens cover',\n  623: 'letter opener, paper knife, paperknife',\n  624: 'library',\n  625: 'lifeboat',\n  626: 'lighter, light, igniter, ignitor',\n  627: 'limousine, limo',\n  628: 'liner, ocean liner',\n  629: 'lipstick, lip rouge',\n  630: 'Loafer',\n  631: 'lotion',\n  632: 'loudspeaker, speaker, speaker unit, loudspeaker system, speaker system',\n  633: 'loupe, jeweler\\'s loupe',\n  634: 'lumbermill, sawmill',\n  635: 'magnetic compass',\n  636: 'mailbag, postbag',\n  637: 'mailbox, letter box',\n  638: 'maillot',\n  639: 'maillot, tank suit',\n  640: 'manhole cover',\n  641: 'maraca',\n  642: 'marimba, xylophone',\n  643: 'mask',\n  644: 'matchstick',\n  645: 'maypole',\n  646: 'maze, labyrinth',\n  647: 'measuring cup',\n  648: 'medicine chest, medicine cabinet',\n  649: 'megalith, megalithic structure',\n  650: 'microphone, mike',\n  651: 'microwave, microwave oven',\n  652: 'military uniform',\n  653: 'milk can',\n  654: 'minibus',\n  655: 'miniskirt, mini',\n  656: 'minivan',\n  657: 'missile',\n  658: 'mitten',\n  659: 'mixing bowl',\n  660: 'mobile home, manufactured home',\n  661: 'Model T',\n  662: 'modem',\n  663: 'monastery',\n  664: 'monitor',\n  665: 'moped',\n  666: 'mortar',\n  667: 'mortarboard',\n  668: 'mosque',\n  669: 'mosquito net',\n  670: 'motor scooter, scooter',\n  671: 'mountain bike, all-terrain bike, off-roader',\n  672: 'mountain tent',\n  673: 'mouse, computer mouse',\n  674: 'mousetrap',\n  675: 'moving van',\n  676: 'muzzle',\n  677: 'nail',\n  678: 'neck brace',\n  679: 'necklace',\n  680: 'nipple',\n  681: 'notebook, notebook computer',\n  682: 'obelisk',\n  683: 'oboe, hautboy, hautbois',\n  684: 'ocarina, sweet potato',\n  685: 'odometer, hodometer, mileometer, milometer',\n  686: 'oil filter',\n  687: 'organ, pipe organ',\n  688: 'oscilloscope, scope, cathode-ray oscilloscope, CRO',\n  689: 'overskirt',\n  690: 'oxcart',\n  691: 'oxygen mask',\n  692: 'packet',\n  693: 'paddle, boat paddle',\n  694: 'paddlewheel, paddle wheel',\n  695: 'padlock',\n  696: 'paintbrush',\n  697: 'pajama, pyjama, pj\\'s, jammies',\n  698: 'palace',\n  699: 'panpipe, pandean pipe, syrinx',\n  700: 'paper towel',\n  701: 'parachute, chute',\n  702: 'parallel bars, bars',\n  703: 'park bench',\n  704: 'parking meter',\n  705: 'passenger car, coach, carriage',\n  706: 'patio, terrace',\n  707: 'pay-phone, pay-station',\n  708: 'pedestal, plinth, footstall',\n  709: 'pencil box, pencil case',\n  710: 'pencil sharpener',\n  711: 'perfume, essence',\n  712: 'Petri dish',\n  713: 'photocopier',\n  714: 'pick, plectrum, plectron',\n  715: 'pickelhaube',\n  716: 'picket fence, paling',\n  717: 'pickup, pickup truck',\n  718: 'pier',\n  719: 'piggy bank, penny bank',\n  720: 'pill bottle',\n  721: 'pillow',\n  722: 'ping-pong ball',\n  723: 'pinwheel',\n  724: 'pirate, pirate ship',\n  725: 'pitcher, ewer',\n  726: 'plane, carpenter\\'s plane, woodworking plane',\n  727: 'planetarium',\n  728: 'plastic bag',\n  729: 'plate rack',\n  730: 'plow, plough',\n  731: 'plunger, plumber\\'s helper',\n  732: 'Polaroid camera, Polaroid Land camera',\n  733: 'pole',\n  734:\n      'police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria',\n  735: 'poncho',\n  736: 'pool table, billiard table, snooker table',\n  737: 'pop bottle, soda bottle',\n  738: 'pot, flowerpot',\n  739: 'potter\\'s wheel',\n  740: 'power drill',\n  741: 'prayer rug, prayer mat',\n  742: 'printer',\n  743: 'prison, prison house',\n  744: 'projectile, missile',\n  745: 'projector',\n  746: 'puck, hockey puck',\n  747: 'punching bag, punch bag, punching ball, punchball',\n  748: 'purse',\n  749: 'quill, quill pen',\n  750: 'quilt, comforter, comfort, puff',\n  751: 'racer, race car, racing car',\n  752: 'racket, racquet',\n  753: 'radiator',\n  754: 'radio, wireless',\n  755: 'radio telescope, radio reflector',\n  756: 'rain barrel',\n  757: 'recreational vehicle, RV, R.V.',\n  758: 'reel',\n  759: 'reflex camera',\n  760: 'refrigerator, icebox',\n  761: 'remote control, remote',\n  762: 'restaurant, eating house, eating place, eatery',\n  763: 'revolver, six-gun, six-shooter',\n  764: 'rifle',\n  765: 'rocking chair, rocker',\n  766: 'rotisserie',\n  767: 'rubber eraser, rubber, pencil eraser',\n  768: 'rugby ball',\n  769: 'rule, ruler',\n  770: 'running shoe',\n  771: 'safe',\n  772: 'safety pin',\n  773: 'saltshaker, salt shaker',\n  774: 'sandal',\n  775: 'sarong',\n  776: 'sax, saxophone',\n  777: 'scabbard',\n  778: 'scale, weighing machine',\n  779: 'school bus',\n  780: 'schooner',\n  781: 'scoreboard',\n  782: 'screen, CRT screen',\n  783: 'screw',\n  784: 'screwdriver',\n  785: 'seat belt, seatbelt',\n  786: 'sewing machine',\n  787: 'shield, buckler',\n  788: 'shoe shop, shoe-shop, shoe store',\n  789: 'shoji',\n  790: 'shopping basket',\n  791: 'shopping cart',\n  792: 'shovel',\n  793: 'shower cap',\n  794: 'shower curtain',\n  795: 'ski',\n  796: 'ski mask',\n  797: 'sleeping bag',\n  798: 'slide rule, slipstick',\n  799: 'sliding door',\n  800: 'slot, one-armed bandit',\n  801: 'snorkel',\n  802: 'snowmobile',\n  803: 'snowplow, snowplough',\n  804: 'soap dispenser',\n  805: 'soccer ball',\n  806: 'sock',\n  807: 'solar dish, solar collector, solar furnace',\n  808: 'sombrero',\n  809: 'soup bowl',\n  810: 'space bar',\n  811: 'space heater',\n  812: 'space shuttle',\n  813: 'spatula',\n  814: 'speedboat',\n  815: 'spider web, spider\\'s web',\n  816: 'spindle',\n  817: 'sports car, sport car',\n  818: 'spotlight, spot',\n  819: 'stage',\n  820: 'steam locomotive',\n  821: 'steel arch bridge',\n  822: 'steel drum',\n  823: 'stethoscope',\n  824: 'stole',\n  825: 'stone wall',\n  826: 'stopwatch, stop watch',\n  827: 'stove',\n  828: 'strainer',\n  829: 'streetcar, tram, tramcar, trolley, trolley car',\n  830: 'stretcher',\n  831: 'studio couch, day bed',\n  832: 'stupa, tope',\n  833: 'submarine, pigboat, sub, U-boat',\n  834: 'suit, suit of clothes',\n  835: 'sundial',\n  836: 'sunglass',\n  837: 'sunglasses, dark glasses, shades',\n  838: 'sunscreen, sunblock, sun blocker',\n  839: 'suspension bridge',\n  840: 'swab, swob, mop',\n  841: 'sweatshirt',\n  842: 'swimming trunks, bathing trunks',\n  843: 'swing',\n  844: 'switch, electric switch, electrical switch',\n  845: 'syringe',\n  846: 'table lamp',\n  847: 'tank, army tank, armored combat vehicle, armoured combat vehicle',\n  848: 'tape player',\n  849: 'teapot',\n  850: 'teddy, teddy bear',\n  851: 'television, television system',\n  852: 'tennis ball',\n  853: 'thatch, thatched roof',\n  854: 'theater curtain, theatre curtain',\n  855: 'thimble',\n  856: 'thresher, thrasher, threshing machine',\n  857: 'throne',\n  858: 'tile roof',\n  859: 'toaster',\n  860: 'tobacco shop, tobacconist shop, tobacconist',\n  861: 'toilet seat',\n  862: 'torch',\n  863: 'totem pole',\n  864: 'tow truck, tow car, wrecker',\n  865: 'toyshop',\n  866: 'tractor',\n  867:\n      'trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi',\n  868: 'tray',\n  869: 'trench coat',\n  870: 'tricycle, trike, velocipede',\n  871: 'trimaran',\n  872: 'tripod',\n  873: 'triumphal arch',\n  874: 'trolleybus, trolley coach, trackless trolley',\n  875: 'trombone',\n  876: 'tub, vat',\n  877: 'turnstile',\n  878: 'typewriter keyboard',\n  879: 'umbrella',\n  880: 'unicycle, monocycle',\n  881: 'upright, upright piano',\n  882: 'vacuum, vacuum cleaner',\n  883: 'vase',\n  884: 'vault',\n  885: 'velvet',\n  886: 'vending machine',\n  887: 'vestment',\n  888: 'viaduct',\n  889: 'violin, fiddle',\n  890: 'volleyball',\n  891: 'waffle iron',\n  892: 'wall clock',\n  893: 'wallet, billfold, notecase, pocketbook',\n  894: 'wardrobe, closet, press',\n  895: 'warplane, military plane',\n  896: 'washbasin, handbasin, washbowl, lavabo, wash-hand basin',\n  897: 'washer, automatic washer, washing machine',\n  898: 'water bottle',\n  899: 'water jug',\n  900: 'water tower',\n  901: 'whiskey jug',\n  902: 'whistle',\n  903: 'wig',\n  904: 'window screen',\n  905: 'window shade',\n  906: 'Windsor tie',\n  907: 'wine bottle',\n  908: 'wing',\n  909: 'wok',\n  910: 'wooden spoon',\n  911: 'wool, woolen, woollen',\n  912: 'worm fence, snake fence, snake-rail fence, Virginia fence',\n  913: 'wreck',\n  914: 'yawl',\n  915: 'yurt',\n  916: 'web site, website, internet site, site',\n  917: 'comic book',\n  918: 'crossword puzzle, crossword',\n  919: 'street sign',\n  920: 'traffic light, traffic signal, stoplight',\n  921: 'book jacket, dust cover, dust jacket, dust wrapper',\n  922: 'menu',\n  923: 'plate',\n  924: 'guacamole',\n  925: 'consomme',\n  926: 'hot pot, hotpot',\n  927: 'trifle',\n  928: 'ice cream, icecream',\n  929: 'ice lolly, lolly, lollipop, popsicle',\n  930: 'French loaf',\n  931: 'bagel, beigel',\n  932: 'pretzel',\n  933: 'cheeseburger',\n  934: 'hotdog, hot dog, red hot',\n  935: 'mashed potato',\n  936: 'head cabbage',\n  937: 'broccoli',\n  938: 'cauliflower',\n  939: 'zucchini, courgette',\n  940: 'spaghetti squash',\n  941: 'acorn squash',\n  942: 'butternut squash',\n  943: 'cucumber, cuke',\n  944: 'artichoke, globe artichoke',\n  945: 'bell pepper',\n  946: 'cardoon',\n  947: 'mushroom',\n  948: 'Granny Smith',\n  949: 'strawberry',\n  950: 'orange',\n  951: 'lemon',\n  952: 'fig',\n  953: 'pineapple, ananas',\n  954: 'banana',\n  955: 'jackfruit, jak, jack',\n  956: 'custard apple',\n  957: 'pomegranate',\n  958: 'hay',\n  959: 'carbonara',\n  960: 'chocolate sauce, chocolate syrup',\n  961: 'dough',\n  962: 'meat loaf, meatloaf',\n  963: 'pizza, pizza pie',\n  964: 'potpie',\n  965: 'burrito',\n  966: 'red wine',\n  967: 'espresso',\n  968: 'cup',\n  969: 'eggnog',\n  970: 'alp',\n  971: 'bubble',\n  972: 'cliff, drop, drop-off',\n  973: 'coral reef',\n  974: 'geyser',\n  975: 'lakeside, lakeshore',\n  976: 'promontory, headland, head, foreland',\n  977: 'sandbar, sand bar',\n  978: 'seashore, coast, seacoast, sea-coast',\n  979: 'valley, vale',\n  980: 'volcano',\n  981: 'ballplayer, baseball player',\n  982: 'groom, bridegroom',\n  983: 'scuba diver',\n  984: 'rapeseed',\n  985: 'daisy',\n  986:\n      'yellow lady\\'s slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum',\n  987: 'corn',\n  988: 'acorn',\n  989: 'hip, rose hip, rosehip',\n  990: 'buckeye, horse chestnut, conker',\n  991: 'coral fungus',\n  992: 'agaric',\n  993: 'gyromitra',\n  994: 'stinkhorn, carrion fungus',\n  995: 'earthstar',\n  996:\n      'hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa',\n  997: 'bolete',\n  998: 'ear, spike, capitulum',\n  999: 'toilet tissue, toilet paper, bathroom tissue'\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\nimport * as webgl_util from '../../src/math/webgl/webgl_util';\n\n/**\n * Unpacks an RGB packed image texture into a 2D physical, 3D logical texture\n * with the conventional ndarray format and performs the standard imagenet image\n * preprocessing.\n */\nexport function getUnpackAndPreprocessInputShader(\n    gpgpu: GPGPUContext, inputShapeRC: [number, number]): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    const vec2 inputShapeCR = vec2(${inputShapeRC[1]}.0, ${inputShapeRC[0]}.0);\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 outputCR = floor(gl_FragCoord.xy);\n\n      vec2 sourceCR = vec2(floor(outputCR[0] / 3.0), outputCR[1]);\n      vec2 sourceUV = (sourceCR + halfCR) / inputShapeCR;\n\n      vec4 sourceValue = texture2D(source, sourceUV) * 255.0;\n\n      float channelValue = 0.0;\n      int channel = int(mod(outputCR[0], 3.0));\n\n      if (channel == 0) {\n        channelValue = sourceValue.r - 103.939;\n      } else if (channel == 1) {\n        channelValue = sourceValue.g - 116.779;\n      } else if (channel == 2) {\n        channelValue = sourceValue.b - 123.68;\n      }\n\n      gl_FragColor = vec4(channelValue, 0, 0, 0);\n    }`;\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function preprocessInput(\n    gpgpu: GPGPUContext, preprocessInputShader: WebGLProgram,\n    sourceTex: WebGLTexture, resultTex: WebGLTexture,\n    shapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]);\n  gpgpu.setProgram(preprocessInputShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.executeProgram();\n}\n\n/**\n * Transposes the depth and the column dimensions of a 3D ndarray represented as\n * a 2D texture into a square collage with each channel rendered as a normalized\n * grayscale image. The normalization bounds are given as two sample2Ds,\n * minValues and maxValues, which give min and max values per channel. These can\n * be computed from a max and min pooling layer.\n */\nexport function getRenderGrayscaleChannelsCollageShader(gpgpu: GPGPUContext):\n    WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    uniform sampler2D minValues;\n    uniform sampler2D maxValues;\n    varying vec2 resultUV;\n\n    uniform float imageSize;\n    uniform float channels;\n    uniform float imagesPerRow;\n    uniform vec2 inputShapeCR;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 outputCR = floor(gl_FragCoord.xy);\n\n      float imageRow = floor(outputCR[1] / imageSize);\n      float imageCol = mod(outputCR[0], imageSize);\n\n      float currentChannel = floor(outputCR[0] / imageSize) +\n          imageRow * imagesPerRow;\n\n      // When the number of channels is not square, we render white to fill in\n      // the output texture.\n      if (currentChannel > channels) {\n        gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n        return;\n      }\n\n      float sourceC = channels * imageCol + currentChannel;\n      float sourceR = mod(outputCR[1], imageSize);\n\n      vec2 sourceUV = (vec2(sourceC, sourceR) + halfCR) / inputShapeCR;\n\n      // Flip the vertical axis of the texture for display since we represent\n      // image textures as vertically flipped.\n      float sourceValue = texture2D(\n          source, vec2(sourceUV.s, 1.0 - sourceUV.t)).r;\n\n      // Normalize the value by sampling the minValues and maxValues texture\n      // which contain min and max per channel.\n      vec2 minMaxValuesShapeCR = vec2(channels, 1);\n      vec2 minMaxValuesCR = vec2(currentChannel, 0);\n      vec2 minMaxValuesUV = (minMaxValuesCR + halfCR) / minMaxValuesShapeCR;\n\n      float minValue = texture2D(minValues, minMaxValuesUV).r;\n      float maxValue = texture2D(maxValues, minMaxValuesUV).r;\n\n      float normalizedValue = (sourceValue - minValue) / (maxValue - minValue);\n\n      gl_FragColor = vec4(\n          normalizedValue, normalizedValue, normalizedValue, 1);\n    }\n  `;\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function renderGrayscaleChannelsCollage(\n    gpgpu: GPGPUContext, unpackChannelsShader: WebGLProgram,\n    sourceTex: WebGLTexture, minValuesTex: WebGLTexture,\n    maxValuesTex: WebGLTexture, inputShapeRC: [number, number],\n    imageSize: number, channels: number, textureSize: number, numRows: number) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  gpgpu.setProgram(unpackChannelsShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.setInputMatrixTexture(minValuesTex, 'minValues', 1);\n  gpgpu.setInputMatrixTexture(maxValuesTex, 'maxValues', 2);\n\n  const imageSizeLoc = gpgpu.getUniformLocation('imageSize');\n  gpgpu.gl.uniform1f(imageSizeLoc, imageSize);\n\n  const channelsLoc = gpgpu.getUniformLocation('channels');\n  gpgpu.gl.uniform1f(channelsLoc, channels);\n\n  const imagesPerRowLoc = gpgpu.getUniformLocation('imagesPerRow');\n  gpgpu.gl.uniform1f(imagesPerRowLoc, Math.floor(textureSize / imageSize));\n\n  const inputShapeCRLoc = gpgpu.getUniformLocation('inputShapeCR');\n  gpgpu.gl.uniform2f(inputShapeCRLoc, inputShapeRC[1], inputShapeRC[0]);\n\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {CheckpointLoader} from '../../src/checkpoint_loader';\nimport {NDArrayMathCPU} from '../../src/math/math_cpu';\nimport {NDArrayMathGPU} from '../../src/math/math_gpu';\nimport {Array1D, Array3D, Array4D, NDArray} from '../../src/math/ndarray';\nimport {GPGPUContext} from '../../src/math/webgl/gpgpu_context';\n\nimport * as imagenet_classes from './imagenet_classes';\nimport * as imagenet_util from './imagenet_util';\n\nconst IMAGE_SIZE = 227;\nconst NUM_CLASSES = 1000;\nconst GOOGLE_CLOUD_STORAGE_DIR =\n    'https://storage.googleapis.com/learnjs-data/checkpoint_zoo/';\n\nexport class SqueezeNet {\n  private variables: {[varName: string]: NDArray};\n\n  private preprocessInputShader: WebGLShader;\n\n  constructor(private gpgpu: GPGPUContext, private math: NDArrayMathGPU) {\n    this.preprocessInputShader =\n        imagenet_util.getUnpackAndPreprocessInputShader(\n            gpgpu, [IMAGE_SIZE, IMAGE_SIZE]);\n  }\n\n  /**\n   * Loads necessary variables for SqueezeNet. Resolves the promise when the\n   * variables have all been loaded.\n   */\n  loadVariables(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const checkpointLoader =\n          new CheckpointLoader(GOOGLE_CLOUD_STORAGE_DIR + 'squeezenet1_1/');\n      checkpointLoader.getAllVariables().then(variables => {\n        this.variables = variables;\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Preprocess an RGB color texture before inferring through squeezenet.\n   * @param rgbTexture The RGB color texture to process into an Array3D.\n   * @param imageDimensions The 2D dimensions of the image.\n   */\n  preprocessColorTextureToArray3D(rgbTexture: WebGLTexture, imageDimensions: [\n    number, number\n  ]): Array3D {\n    const preprocessResultShapeRC: [number, number] =\n        [imageDimensions[0], imageDimensions[0] * 3];\n\n    const preprocessResultTexture =\n        this.math.getTextureManager().acquireTexture(preprocessResultShapeRC);\n\n    imagenet_util.preprocessInput(\n        this.gpgpu, this.preprocessInputShader, rgbTexture,\n        preprocessResultTexture, preprocessResultShapeRC);\n    return NDArray.make<Array3D>([imageDimensions[0], imageDimensions[0], 3], {\n      texture: preprocessResultTexture,\n      textureShapeRC: preprocessResultShapeRC\n    });\n  }\n\n  /**\n   * Infer through SqueezeNet, assumes variables have been loaded. This does\n   * standard ImageNet pre-processing before inferring through the model. This\n   * method returns named activations as well as pre-softmax logits. The user\n   * needs to clean up namedActivations after inferring.\n   *\n   * @param preprocessedInput preprocessed input Array.\n   * @return Named activations and the pre-softmax logits.\n   */\n  infer(preprocessedInput: Array3D):\n      {namedActivations: {[activationName: string]: Array3D}, logits: Array1D} {\n    const namedActivations: {[key: string]: Array3D} = {};\n\n    const avgpool10 = this.math.scope((keep) => {\n      const conv1 = this.math.conv2d(\n          preprocessedInput, this.variables['conv1_W:0'] as Array4D,\n          this.variables['conv1_b:0'] as Array1D, 2, 0);\n      const conv1relu = keep(this.math.relu(conv1));\n      namedActivations['conv_1'] = conv1relu;\n\n      const pool1 = keep(this.math.maxPool(conv1relu, 3, 2, 0));\n      namedActivations['maxpool_1'] = pool1;\n\n      const fire2 = keep(this.fireModule(pool1, 2));\n      namedActivations['fire2'] = fire2;\n\n      const fire3 = keep(this.fireModule(fire2, 3));\n      namedActivations['fire3'] = fire3;\n\n      // Because we don't have uneven padding yet, manually pad the ndarray on\n      // the right.\n      const fire3Reshape2d =\n          fire3.as2D(fire3.shape[0], fire3.shape[1] * fire3.shape[2]);\n      const fire3Sliced2d = this.math.slice2D(\n          fire3Reshape2d, [0, 0],\n          [fire3.shape[0] - 1, (fire3.shape[1] - 1) * fire3.shape[2]]);\n      const fire3Sliced = fire3Sliced2d.as3D(\n          fire3.shape[0] - 1, fire3.shape[1] - 1, fire3.shape[2]);\n      const pool2 = keep(this.math.maxPool(fire3Sliced, 3, 2, 0));\n      namedActivations['maxpool_2'] = pool2;\n\n      const fire4 = keep(this.fireModule(pool2, 4));\n      namedActivations['fire4'] = fire4;\n\n      const fire5 = keep(this.fireModule(fire4, 5));\n      namedActivations['fire5'] = fire5;\n\n      const pool3 = keep(this.math.maxPool(fire5, 3, 2, 0));\n      namedActivations['maxpool_3'] = pool3;\n\n      const fire6 = keep(this.fireModule(pool3, 6));\n      namedActivations['fire6'] = fire6;\n\n      const fire7 = keep(this.fireModule(fire6, 7));\n      namedActivations['fire7'] = fire7;\n\n      const fire8 = keep(this.fireModule(fire7, 8));\n      namedActivations['fire8'] = fire8;\n\n      const fire9 = keep(this.fireModule(fire8, 9));\n      namedActivations['fire9'] = fire9;\n\n      const conv10 = keep(this.math.conv2d(\n          fire9, this.variables['conv10_W:0'] as Array4D,\n          this.variables['conv10_b:0'] as Array1D, 1, 0));\n      namedActivations['conv10'] = conv10;\n\n      return this.math.avgPool(conv10, conv10.shape[0], 1, 0).as1D();\n    });\n\n    return {namedActivations, logits: avgpool10};\n  }\n\n  private fireModule(input: Array3D, fireId: number) {\n    const y1 = this.math.conv2d(\n        input, this.variables['fire' + fireId + '/squeeze1x1_W:0'] as Array4D,\n        this.variables['fire' + fireId + '/squeeze1x1_b:0'] as Array1D, 1, 0);\n    const y2 = this.math.relu(y1);\n    const left1 = this.math.conv2d(\n        y2, this.variables['fire' + fireId + '/expand1x1_W:0'] as Array4D,\n        this.variables['fire' + fireId + '/expand1x1_b:0'] as Array1D, 1, 0);\n    const left2 = this.math.relu(left1);\n\n    const right1 = this.math.conv2d(\n        y2, this.variables['fire' + fireId + '/expand3x3_W:0'] as Array4D,\n        this.variables['fire' + fireId + '/expand3x3_b:0'] as Array1D, 1, 1);\n    const right2 = this.math.relu(right1);\n\n    return this.math.concat3D(left2, right2, 2);\n  }\n\n  /**\n   * Get the topK classes for pre-softmax logits. Returns a map of className\n   * to softmax normalized probability.\n   *\n   * @param logits Pre-softmax logits array.\n   * @param topK How many top classes to return.\n   */\n  getTopKClasses(logits: Array1D, topK: number): {[className: string]: number} {\n    const predictions = this.math.softmax(logits);\n    const topk = new NDArrayMathCPU().topK(predictions, topK);\n    const topkIndices = topk.indices.getValues();\n    const topkValues = topk.values.getValues();\n\n    const topClassesToProbability: {[className: string]: number} = {};\n    for (let i = 0; i < topkIndices.length; i++) {\n      topClassesToProbability[imagenet_classes\n                                  .IMAGENET_CLASSES[topkIndices[i]]] =\n          topkValues[i];\n    }\n    return topClassesToProbability;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * @fileoverview\n *\n * Defines an interface for creating Polymer elements in Typescript with the\n * correct typings. A Polymer element should be defined like this:\n *\n * ```\n * let MyElementPolymer = PolymerElement({\n *   is: 'my-polymer-element',\n *   properties: {\n *     foo: string,\n *     bar: Array\n *   }\n * });\n *\n * class MyElement extends MyElementPolymer {\n *   foo: string;\n *   bar: number[];\n *\n *   ready() {\n *     console.log('MyElement initialized!');\n *   }\n * }\n *\n * document.registerElement(MyElement.prototype.is, MyElement);\n * ```\n */\n\nexport type Spec = {\n  is: string; properties: {\n    [key: string]: (Function|{\n      // tslint:disable-next-line:no-any\n      type: Function, value?: any;\n      reflectToAttribute?: boolean;\n      readonly?: boolean;\n      notify?: boolean;\n      computed?: string;\n      observer?: string;\n    })\n  };\n  observers?: string[];\n};\n\nexport function PolymerElement(spec: Spec) {\n  // tslint:disable-next-line:no-any\n  return Polymer.Class(spec as any) as {new (): PolymerHTMLElement};\n}\n\nexport interface PolymerHTMLElement extends HTMLElement, polymer.Base {}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * @hidden\n */\nexport interface CheckpointVariable {\n  filename: string;\n  shape: number[];\n}\n\n/**\n * @hidden\n */\nexport type CheckpointManifest = {\n  [varName: string]: CheckpointVariable\n};\n\nconst MANIFEST_FILE = 'manifest.json';\n\nexport class CheckpointLoader {\n  private checkpointManifest: CheckpointManifest;\n  private variables: {[varName: string]: NDArray};\n\n  constructor(private urlPath: string) {\n    if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') {\n      this.urlPath += '/';\n    }\n  }\n\n  private loadManifest(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n      xhr.open('GET', this.urlPath + MANIFEST_FILE);\n\n      xhr.onload = () => {\n        this.checkpointManifest = JSON.parse(xhr.responseText);\n        resolve();\n      };\n      xhr.onerror = (error) => {\n        throw new Error(\n            `${MANIFEST_FILE} not found at ${this.urlPath}. ` + error);\n      };\n      xhr.send();\n    });\n  }\n\n  getCheckpointManifest(): Promise<CheckpointManifest> {\n    if (this.checkpointManifest == null) {\n      return new Promise<CheckpointManifest>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          resolve(this.checkpointManifest);\n        });\n      });\n    }\n    return new Promise<CheckpointManifest>((resolve, reject) => {\n      resolve(this.checkpointManifest);\n    });\n  }\n\n  getAllVariables(): Promise<{[varName: string]: NDArray}> {\n    if (this.variables != null) {\n      return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n        resolve(this.variables);\n      });\n    }\n\n    return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n      this.getCheckpointManifest().then(\n          (checkpointDefinition: CheckpointManifest) => {\n            const variableNames = Object.keys(this.checkpointManifest);\n\n            const variablePromises: Array<Promise<NDArray>> = [];\n            for (let i = 0; i < variableNames.length; i++) {\n              variablePromises.push(this.getVariable(variableNames[i]));\n            }\n\n            Promise.all(variablePromises).then(variables => {\n              this.variables = {};\n              for (let i = 0; i < variables.length; i++) {\n                this.variables[variableNames[i]] = variables[i];\n              }\n              resolve(this.variables);\n            });\n          });\n    });\n  }\n\n  getVariable(varName: string): Promise<NDArray> {\n    if (!(varName in this.checkpointManifest)) {\n      throw new Error('Cannot load non-existant variable ' + varName);\n    }\n\n    const variableRequestPromiseMethod =\n        (resolve: (ndarray: NDArray) => void, reject: () => void) => {\n          const xhr = new XMLHttpRequest();\n          xhr.responseType = 'arraybuffer';\n          const fname = this.checkpointManifest[varName].filename;\n          xhr.open('GET', this.urlPath + fname);\n\n          xhr.onload = () => {\n            const values = new Float32Array(xhr.response);\n            const ndarray =\n                NDArray.make(this.checkpointManifest[varName].shape, {values});\n            resolve(ndarray);\n          };\n          xhr.onerror = (error) => {\n            throw new Error(\n                'Could not fetch variable ' + varName + ': ' + error);\n          };\n          xhr.send();\n        };\n\n    if (this.checkpointManifest == null) {\n      return new Promise<NDArray>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          new Promise<NDArray>(variableRequestPromiseMethod).then(resolve);\n        });\n      });\n    }\n    return new Promise<NDArray>(variableRequestPromiseMethod);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\nconst STATS_SAMPLE_PERCENTAGE = 0.1;\n\nexport interface DataStats {\n  exampleCount: number;\n  inputMin: number;\n  inputMax: number;\n  shape: number[];\n}\n\ninterface NormalizationInfo {\n  isNormalized: boolean;\n  // Bounds of the normalization if normalized.\n  lowerBound?: number;\n  upperBound?: number;\n  // Minimum and maximum values for each dimension of the original data. These\n  // are the same size as an input example. These are computed lazily, only if\n  // normalization is requested. If the data is un-normalized, these are kept\n  // around so they don't have to be recomputed.\n  minValues: Float32Array;\n  maxValues: Float32Array;\n}\n\nexport abstract class InMemoryDataset {\n  protected dataset: NDArray[][]|null;\n\n  // Contains information necessary for reconstruction of the original data\n  // after normalization.\n  private normalizationInfo: {[dataIndex: number]: NormalizationInfo};\n\n  constructor(protected dataShapes: number[][]) {\n    this.normalizationInfo = {};\n  }\n\n  getDataShape(dataIndex: number): number[] {\n    return this.dataShapes[dataIndex];\n  }\n\n  abstract fetchData(): Promise<void>;\n\n  getData(): NDArray[][]|null {\n    return this.dataset;\n  }\n\n  getStats(): DataStats[] {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    return this.dataset.map(d => this.getStatsForData(d));\n  }\n\n  // Computes stats across a sampled portion of the data.\n  private getStatsForData(data: NDArray[]): DataStats {\n    let inputMin = Number.POSITIVE_INFINITY;\n    let inputMax = Number.NEGATIVE_INFINITY;\n\n    let exampleIndices = data.map((example, i) => i);\n    util.shuffle(exampleIndices);\n    exampleIndices =\n        exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE);\n\n    for (let i = 0; i < exampleIndices.length; i++) {\n      const inputValues = data[exampleIndices[i]].getValues();\n      for (let j = 0; j < inputValues.length; j++) {\n        inputMin = Math.min(inputMin, inputValues[j]);\n        inputMax = Math.max(inputMax, inputValues[j]);\n      }\n    }\n\n    return {\n      inputMin,\n      inputMax,\n      exampleCount: data.length,\n      shape: data[0].shape,\n    };\n  }\n\n  /**\n   * @param examples NDArrays to be normalized.\n   * @param curLowerBounds An array containing the minimum value for each\n   * dimension or a fixed minimum value.\n   * @param curUpperBounds An array containing the maximum value for each\n   * dimension or a fixed maximum value.\n   * @param newLowerBounds An array containing new minimum values for each\n   * dimension, or a fixed minumum value to normalize the data to.\n   * @param newUpperBounds An array containing new maximum values for each\n   * dimension, or a fixed maximum value to normalize the data to.\n   */\n  private normalizeExamplesToRange(\n      examples: NDArray[], curLowerBounds: Float32Array|number,\n      curUpperBounds: Float32Array|number, newLowerBounds: Float32Array|number,\n      newUpperBounds: Float32Array|number): NDArray[] {\n    const curBoundsIsPerDimension =\n        (curUpperBounds instanceof Float32Array &&\n         curLowerBounds instanceof Float32Array);\n    const newBoundsIsPerDimension =\n        (newLowerBounds instanceof Float32Array &&\n         newUpperBounds instanceof Float32Array);\n\n    const inputSize = util.sizeFromShape(examples[0].shape);\n    const newExamples: NDArray[] = [];\n\n    examples.forEach(example => {\n      const inputValues = example.getValues();\n      const normalizedValues = new Float32Array(inputSize);\n      for (let j = 0; j < inputSize; j++) {\n        const curLowerBound = curBoundsIsPerDimension ?\n            (curLowerBounds as Float32Array)[j] :\n            curLowerBounds as number;\n        const curUpperBound = curBoundsIsPerDimension ?\n            (curUpperBounds as Float32Array)[j] :\n            curUpperBounds as number;\n        const curRange = curUpperBound - curLowerBound;\n\n        const newLowerBound = newBoundsIsPerDimension ?\n            (newLowerBounds as Float32Array)[j] :\n            newLowerBounds as number;\n        const newUpperBound = newBoundsIsPerDimension ?\n            (newUpperBounds as Float32Array)[j] :\n            newUpperBounds as number;\n        const newRange = newUpperBound - newLowerBound;\n\n        if (curRange === 0) {\n          normalizedValues[j] = newLowerBound;\n        } else {\n          normalizedValues[j] = newLowerBound +\n              newRange * (inputValues[j] - curLowerBound) / curRange;\n        }\n      }\n      newExamples.push(NDArray.make(example.shape, {values: normalizedValues}));\n    });\n    return newExamples;\n  }\n\n  private computeBounds(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    const size = util.sizeFromShape(this.dataset[dataIndex][0].shape);\n\n    // Compute min and max values for every dimension.\n    this.normalizationInfo[dataIndex] = {\n      isNormalized: false,\n      minValues: new Float32Array(size),\n      maxValues: new Float32Array(size)\n    };\n\n    for (let i = 0; i < size; i++) {\n      this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY;\n      this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY;\n    }\n\n    this.dataset[dataIndex].forEach(example => {\n      const inputValues = example.getValues();\n      for (let k = 0; k < size; k++) {\n        this.normalizationInfo[dataIndex].minValues[k] = Math.min(\n            this.normalizationInfo[dataIndex].minValues[k], inputValues[k]);\n        this.normalizationInfo[dataIndex].maxValues[k] = Math.max(\n            this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]);\n      }\n    });\n  }\n\n  normalizeWithinBounds(\n      dataIndex: number, lowerBound: number, upperBound: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n    if (dataIndex >= this.dataset.length) {\n      throw new Error('dataIndex out of bounds.');\n    }\n\n    if (this.normalizationInfo[dataIndex] == null) {\n      this.computeBounds(dataIndex);\n    }\n\n    // curLower/UpperBounds of the current data set can either be fixed numbers\n    // if the data has already been normalized, or curLower/Upper for each\n    // dimension if it hasn't been normalized yet.\n    let curLowerBounds: Float32Array|number;\n    let curUpperBounds: Float32Array|number;\n\n    if (this.normalizationInfo[dataIndex].isNormalized) {\n      curLowerBounds = this.normalizationInfo[dataIndex].lowerBound!;\n      curUpperBounds = this.normalizationInfo[dataIndex].upperBound!;\n    } else {\n      curLowerBounds = this.normalizationInfo[dataIndex].minValues;\n      curUpperBounds = this.normalizationInfo[dataIndex].maxValues;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound,\n        upperBound);\n    this.normalizationInfo[dataIndex].isNormalized = true;\n    this.normalizationInfo[dataIndex].lowerBound = lowerBound;\n    this.normalizationInfo[dataIndex].upperBound = upperBound;\n  }\n\n  private isNormalized(dataIndex: number): boolean {\n    return this.normalizationInfo != null &&\n        this.normalizationInfo[dataIndex].isNormalized;\n  }\n\n  removeNormalization(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Training or test data is null.');\n    }\n\n    if (!this.isNormalized(dataIndex)) {\n      return;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n    this.normalizationInfo[dataIndex].isNormalized = false;\n  }\n\n  unnormalizeExamples(examples: NDArray[], dataIndex: number): NDArray[] {\n    if (!this.isNormalized(dataIndex)) {\n      return examples;\n    }\n\n    return this.normalizeExamplesToRange(\n        examples, this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n  }\n\n  dispose() {\n    if (this.dataset == null) {\n      return;\n    }\n\n    for (let i = 0; i < this.dataset.length; i++) {\n      for (let j = 0; j < this.dataset[i].length; j++) {\n        this.dataset[i][j].dispose();\n      }\n    }\n    this.dataset = [];\n  }\n}\n\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GraphLayers} from './graph_layers';\nimport * as concat3d_util from './math/concat3d_util';\nimport * as conv_util from './math/conv_util';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * Graph is the primary container structure for learn.js operations. Graph\n * holds the topology of operation nodes and the connectivity between them.\n */\nexport class Graph {\n  layers: GraphLayers;\n\n  constructor() {\n    this.layers = new GraphLayers(this);\n  }\n\n  /**\n   * Creates a named variable. Variables are tensors that maintain state across\n   * session calls and whose values are adjusted during backpropagation\n   * training.\n   * @param name The name of this variable.\n   * @param data The NDArray to associate with this variable tensor.\n   * @return The tensor representing the variable.\n   */\n  variable(name: string, data: NDArray): Tensor {\n    return this.addNodeAndReturnOutput(new VariableNode(this, name, data));\n  }\n\n  /**\n   * Inserts a placeholder for a tensor that will be always fed. Placeholders\n   * are input tensors whose values are provided by the client via feed\n   * dictionaries. Placeholders are not updated as part of training; they are\n   * only used as immutable input.\n   * @param name The name of this placeholder.\n   * @param shape The shape of the placeholder tensor.\n   * @return The tensor representing the placeholder.\n   */\n  placeholder(name: string, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape));\n  }\n\n  /**\n   * Constant value that persists across session calls.\n   * @param value The value to return.\n   * @return A node outputing the constant value.\n   */\n  constant(value: ArrayData): Tensor {\n    let finalValue: NDArray;\n    if (typeof value === 'number') {\n      finalValue = Scalar.new(value);\n    } else if (value instanceof NDArray) {\n      finalValue = value;\n    } else if (value instanceof Array) {\n      const vals = new Float32Array(util.flatten(value));\n      finalValue = NDArray.make(util.inferShape(value), {values: vals});\n    } else {\n      throw new Error('unimplemented constant type.');\n    }\n    return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue));\n  }\n\n  /**\n   * Reshape the input tensor.\n   * @param x The input tensor to be reshaped.\n   * @param shape The shape of the output tensor.\n   * @return The tensor representing the reshape operation.\n   */\n  reshape(x: Tensor, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(\n        new ReshapeNode(this, 'Reshape', x, shape));\n  }\n\n  /**\n   * Computes a fused linear combination of two tensors.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor. Same shape as t1.\n   * @param c1 Coefficient of t1. Must be size 1.\n   * @param c2 Coefficient of t2. Must be size 1.\n   * @return The tensor representing c1*t1+c2*t2.\n   */\n  fusedLinearCombination(x1: Tensor, x2: Tensor, c1: Tensor, c2: Tensor):\n      Tensor {\n    return this.addNodeAndReturnOutput(\n        new FusedLinearCombinationNode(this, x1, x2, c1, c2));\n  }\n\n\n  /**\n   * Adds two tensors (elementwise). Broadcasts if one of the tensors is scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1+t2.\n   */\n  add(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new AddNode(this, x1, x2));\n  }\n\n  /**\n   * Subtracts two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1-t2.\n   */\n  subtract(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2));\n  }\n\n  /**\n   * Multiply two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1*t2.\n   */\n  multiply(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2));\n  }\n\n  /**\n   * Divide two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1 / t2.\n   */\n  divide(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2));\n  }\n\n  /**\n   * Computes the sum of elements in the tensor.\n   * @param x The input tensor.\n   */\n  reduceSum(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReduceSumNode(this, x));\n  }\n\n  /**\n   * Concats two 3D tensors along a given axis.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing concat of two tensors along axis.\n   */\n  concat3d(x1: Tensor, x2: Tensor, axis: number): Tensor {\n    return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis));\n  }\n\n  /**\n   * Computes the dot product between two matrices.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing the dot product of x1 and x2.\n   */\n  matmul(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2));\n  }\n\n  /**\n   * Computes a 2D convolution.\n   * @param x The input tensor to the convolution operation.\n   * @param w The weight tensor used by the convolution operation.\n   * @param b The bias tensor used by the convolution operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param outputDepth The output depth of the convolution operation.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the convolution operation.\n   */\n  conv2d(\n      x: Tensor, w: Tensor, b: Tensor, fieldSize: number, outputDepth: number,\n      stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(new Convolution2DNode(\n        this, x, w, b, fieldSize, outputDepth, stride, zeroPad));\n  }\n\n  /**\n   * Computes a 2D max pool of x.\n   * @param x The input tensor to the max pool operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the max pool operation.\n   */\n  maxPool(x: Tensor, fieldSize: number, stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(\n        new MaxPoolNode(this, x, fieldSize, stride, zeroPad));\n  }\n\n  /**\n   * Computes exponential of x element-wise.\n   * @param x The input tensor to the exp.\n   * @return The tensor representing the e ^ x operation.\n   */\n  exp(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ExpNode(this, x));\n  }\n\n  /**\n   * Computes log of x element-wise.\n   * @param x The input tensor to the log.\n   * @return The tensor representing the ln(x) operation.\n   */\n  log(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new LogNode(this, x));\n  }\n\n  /**\n   * Computes ReLU of x element-wise.\n   * @param x The input tensor to the ReLU.\n   * @return The tensor representing the ReLU operation.\n   */\n  relu(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReLUNode(this, x));\n  }\n\n  /**\n   * Computes TanH of x element-wise.\n   * @param x The input tensor to the TanH.\n   * @return The tensor representing the TanH operation.\n   */\n  tanh(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new TanHNode(this, x));\n  }\n\n  /**\n   * Computes Sigmoid of x element-wise.\n   * @param x The input tensor to the sigmoid.\n   * @return The tensor representing the sigmoid operation.\n   */\n  sigmoid(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SigmoidNode(this, x));\n  }\n\n  /**\n   * Computes square of x element-wise.\n   * @param x The input tensor to the square.\n   */\n  square(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SquareNode(this, x));\n  }\n\n  /**\n   * Computes softmax probabilities from logits.\n   *\n   * @param x The input logits.\n   * @return The softmax probabilities.\n   */\n  softmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SoftmaxNode(this, x));\n  }\n\n  /**\n   * Creates a softmax cross-entropy cost operation in the graph.\n   * @param x The input tensor to classify.\n   * @return The tensor representing the softmax cross-entropy cost operation.\n   */\n  softmaxCrossEntropyCost(x: Tensor, target: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(\n        new SoftmaxCrossEntropyCostNode(this, x, target));\n  }\n\n  /**\n   * Creates a mean-squared cost operation in the graph.\n   * @param label The label tensor.\n   * @param prediction The prediction tensor.\n   * @return The tensor representing the mean-squared cost operation.\n   */\n  meanSquaredCost(label: Tensor, prediction: Tensor) {\n    return this.addNodeAndReturnOutput(\n        new MeanSquaredCostNode(this, label, prediction));\n  }\n\n  /**\n   * Returns the flattened index of the maximum entry in the tensor.\n   * @param x The tensor with the value.\n   * @return A Scalar tensor with the index of the maximum entry.\n   */\n  argmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxNode(this, x));\n  }\n\n  /**\n   * Creates an argmax equals operation in the graph.\n   * @param x1 First input tensor to check against.\n   * @param x2 Second input tensor to check against.\n   * @return The tensor representing the argmax equals operation.\n   */\n  argmaxEquals(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2));\n  }\n\n  private addNodeAndReturnOutput(node: Node): Tensor {\n    this.nodes.push(node);\n    node.validate();\n    return node.output;\n  }\n\n  getNodes(): Node[] {\n    return this.nodes;\n  }\n\n  private nodes: Node[] = [];\n}\n\n/**\n * Tensor represents the output of an operation node in the graph.\n * Tensors have no data associated with them, but maintain a shape array\n * to determine operation compatibility. All graph methods that create graph\n * operations return Tensor objects, which can be thought of as 'handles' to\n * operations.\n */\nexport class Tensor {\n  node: Node;\n  id: number;\n  /**\n   * @param shape The shape of this tensor, in dimension sizes.\n   */\n  constructor(public shape: number[]) {\n    this.id = Tensor.nextID++;\n  }\n  private static nextID = 0;\n}\n\n/**\n * Node is the concrete base class for all operations in the graph.\n * Users generally don't need to interact directly with Node instances, but they\n * are provided for informational and introspection purposes.\n *\n * @hidden\n */\nexport abstract class Node {\n  /**\n   * @param graph The graph containing this node\n   * @param name The name of this node\n   * @param inputs A dictionary of named Tensors that comprise this node's\n   * inputs.\n   * @param output This node's output Tensor\n   */\n  constructor(\n      public graph: Graph, public name: string,\n      public inputs: {[name: string]: Tensor}, public output: Tensor) {\n    this.id = Node.nextID++;\n    output.node = this;\n  }\n  abstract validate(): void;\n  id: number;\n  private static nextID = 0;\n}\n\n/**\n * VariableNode represents a variable, a user-provided NDArray that's\n * adjusted during backpropagation training.\n *\n * @hidden\n */\nexport class VariableNode extends Node {\n  constructor(graph: Graph, name: string, public data: NDArray) {\n    super(graph, name, {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding variable op: Data for variable \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * PlaceholderNode represents a placeholder, a user-provided NDArray\n * that's used as immutable input during inference and training.\n *\n * @hidden\n */\nexport class PlaceholderNode extends Node {\n  constructor(graph: Graph, name: string, shape: number[]) {\n    super(graph, name, {}, new Tensor(shape));\n  }\n  validate() {}\n}\n\n/**\n * ConstantNode represents a constant value in the graph.\n *\n * @hidden\n */\nexport class ConstantNode extends Node {\n  constructor(graph: Graph, public data: NDArray) {\n    super(graph, 'Constant', {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding constant: data for placeholder \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * ReshapeNode represents a reshape operation in the graph.\n *\n * @hidden\n */\nexport class ReshapeNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, public name: string, private x: Tensor,\n      private shape: number[]) {\n    super(graph, name, {x}, new Tensor(shape));\n  }\n  validate() {\n    const xSize = util.sizeFromShape(this.x.shape);\n    const shapeSize = util.sizeFromShape(this.shape);\n    util.assert(\n        xSize === shapeSize,\n        'Error making reshape operation: input Tensor to reshape \\'' +\n            this.name + '\\' of shape (' + this.x.shape +\n            ') does not match size of requested shape ' + this.shape + '.');\n  }\n}\n\n/**\n * LinearCombinationNode represents a linear combination of two tensors.\n * @hidden\n */\nexport class FusedLinearCombinationNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n  static readonly C1 = 'c1';\n  static readonly C2 = 'c2';\n  constructor(\n      graph: Graph, private t1: Tensor, private t2: Tensor, private c1: Tensor,\n      private c2: Tensor) {\n    super(graph, 'Linear Combination', {t1, t2, c1, c2}, new Tensor(t1.shape));\n  }\n\n  validate() {\n    util.assertShapesMatch(this.t1.shape, this.t2.shape);\n    if (!util.isScalarShape(this.c1.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c1 is not a scalar, got ' +\n          'shape: ' + this.c1.shape);\n    }\n    if (!util.isScalarShape(this.c2.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c2 is not a scalar, got ' +\n          'shape: ' + this.c2.shape);\n    }\n  }\n}\n\n/**\n * @hidden\n */\nexport class AddNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Add', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding add operation op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SubtractNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Subtract', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding subtract op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class MultiplyNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Multiply', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding multiply op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class DivideNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Divide', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding divide op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReduceSumNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReduceSum', {x}, new Tensor([]));\n  }\n\n  validate() {}\n}\n\n/**\n * Concat3DNode represents a 3D concatenation of two tensors along an axis.\n * @hidden\n */\nexport class Concat3DNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  static readonly AXIS = 'axis';\n  constructor(\n      graph: Graph, private x1: Tensor, private x2: Tensor,\n      public axis: number) {\n    super(\n        graph, 'Concat3D', {x1, x2},\n        new Tensor(concat3d_util.computeConcat3DOutputShape(\n            x1.shape, x2.shape, axis)));\n  }\n  validate() {\n    concat3d_util.assertConcat3DShapesMatch(\n        this.x1.shape, this.x2.shape, this.axis);\n  }\n}\n\nfunction getMatMulOutputShape(x1Shape: number[], x2Shape: number[]): number[] {\n  if (x1Shape.length === 1 && x2Shape.length === 1) {\n    return [1];\n  } else if (x1Shape.length === 1 && x2Shape.length === 2) {\n    return [x2Shape[1]];\n  } else if (x1Shape.length === 2 && x2Shape.length === 1) {\n    return [x1Shape[0]];\n  }\n  return [x1Shape[0], x2Shape[1]];\n}\n\n/**\n * MatMulNode represents a fully connected layer in the graph.\n * @hidden\n */\nexport class MatMulNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(\n        graph, 'MatMul', {x1, x2},\n        new Tensor(getMatMulOutputShape(x1.shape, x2.shape)));\n  }\n\n  validate() {\n    if (this.x1.shape.length === 2 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: inner shapes of matrices with shapes ' +\n              this.x1.shape + ' and ' + this.x2.shape + ' must match.');\n    } else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: second dimension of matrix with shape ' +\n              this.x1.shape + ' must match size of vector with shape ' +\n              this.x2.shape + '.');\n    } else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[0] === this.x2.shape[0],\n          'Error adding matmul op: size of vector with shape ' + this.x1.shape +\n              ' must match first dimension of matrix with ' +\n              'shape ' + this.x2.shape + '.');\n    } else {\n      throw new Error(\n          'Error adding matmul op: inputs must be vectors or matrices.');\n    }\n  }\n}\n\n/**\n * Convolution2DNode represents a 2d convolution operation in the graph.\n * @hidden\n */\nexport class Convolution2DNode extends Node {\n  static readonly X = 'x';\n  static readonly W = 'w';\n  static readonly B = 'b';\n  constructor(\n      graph: Graph, private x: Tensor, private w: Tensor, private b: Tensor,\n      public fieldSize: number, public outputDepth: number, public stride = 1,\n      public zeroPad?: number) {\n    super(\n        graph, 'Convolution 2D', {x, w, b},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, outputDepth, stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding conv2d op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n    util.assert(\n        this.w.shape.length === 4,\n        'Error adding conv2d op: weights must be of rank 4, but got shape: ' +\n            this.w.shape + '.');\n    util.assert(\n        this.b.shape.length === 1,\n        'Error adding conv2d op: biases must be of rank 1, but got shape: ' +\n            this.b.shape + '.');\n\n    util.assert(\n        this.x.shape[2] === this.w.shape[2],\n        'Error adding conv2d op: depth of input (' + this.x.shape[2] +\n            ') must match input depth for weights (' + this.w.shape[2] + ').');\n  }\n}\n\n/**\n * MaxPoolNode represents a 2d max pool operation in the graph.\n * @hidden\n */\nexport class MaxPoolNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, private x: Tensor, public fieldSize: number,\n      public stride = 1, public zeroPad?: number) {\n    super(\n        graph, 'Max pool', {x},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, x.shape[2], stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding maxPool op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n  }\n}\n\n/**\n * ReLUNode represents a ReLU operation in the graph.\n * @hidden\n */\nexport class ReLUNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReLU', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * ExpNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class ExpNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Exp', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * LogNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class LogNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Log', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * TanHNode represents a tanh operation in the graph.\n * @hidden\n */\nexport class TanHNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'TanH', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SigmoidNode represents a sigmoid operation in the graph.\n * @hidden\n */\nexport class SigmoidNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Sigmoid', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * Square node represents an element-wise square operation in the graph.\n * @hidden\n */\nexport class SquareNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Square', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SoftmaxCrossEntropyCostNode represents a softmax cross-entropy cost operation\n * in the graph.\n * @hidden\n */\nexport class SoftmaxCrossEntropyCostNode extends Node {\n  static readonly X = 'x';\n  static readonly TARGET = 'target';\n  constructor(graph: Graph, private x: Tensor, private target: Tensor) {\n    super(graph, 'SoftmaxCrossEntropyCost', {x, target}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x.shape, this.target.shape),\n        'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape +\n            ') must match target shape (' + this.target.shape + ').');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SoftmaxNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, private x: Tensor) {\n    super(graph, 'Softmax', {x}, new Tensor(x.shape));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 1,\n        'The input to a softmax must be a 1-D tensor');\n    util.assert(\n        this.x.shape[0] >= 2,\n        'The input to a softmax must have at least 2 values');\n  }\n}\n\n/**\n * MeanSquaredCostNode represents a mean squared cost operation\n * in the graph.\n *\n * @hidden\n */\nexport class MeanSquaredCostNode extends Node {\n  static readonly LABEL = 'label';\n  static readonly PREDICTION = 'prediction';\n  constructor(graph: Graph, private label: Tensor, private prediction: Tensor) {\n    super(graph, 'Mean Squared Cost', {label, prediction}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.label.shape, this.prediction.shape),\n        'Error adding meanSquaredCost op: label shape (' + this.label.shape +\n            ') must match prediction shape (' + this.prediction.shape + ').');\n  }\n}\n\n/**\n * ArgMaxNode represents an argmax operation in the graph.\n * @hidden\n */\nexport class ArgMaxNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, public x: Tensor) {\n    super(graph, 'ArgMax', {x}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.x.shape) > 0,\n        'Error adding argmax op: input tensor must have at least one entry.');\n  }\n}\n\n/**\n * ArgMaxEqualsNode represents a argmax equals operation in the graph.\n * @hidden\n */\nexport class ArgMaxEqualsNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(graph, 'ArgMaxEquals', {x1, x2}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x1.shape, this.x2.shape),\n        'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape +\n            ') must match x2 shape (' + this.x2.shape + ').');\n  }\n}\n\n/**\n * Split nodes are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n * @hidden\n */\nexport class SplitNode extends Node {\n  static readonly X = 'x';\n\n  outputs: Tensor[] = [];\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'SplitNode', {x}, new Tensor(x.shape));\n  }\n\n  /**\n   * Registers a new consumer of this split node, i.e. a new node that uses the\n   * node's output tensor.\n   */\n  getNewOutputTensor(): Tensor {\n    const output = new Tensor(this.inputs[SplitNode.X].shape);\n    output.node = this;\n    this.outputs.push(output);\n    return output;\n  }\n  validate() {}\n}\n\n/**\n * @hidden\n */\nexport type ArrayData =\n    NDArray|number|number[]|number[][]|number[][][]|number[][][][];\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Tensor} from './graph';\nimport {Initializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nimport {NDArray} from './math/ndarray';\n\n/**\n * A layers sugar class around the graph that initializes variables\n * automatically for layers.\n */\nexport class GraphLayers {\n  constructor(private g: Graph) {}\n\n  dense(\n      name: string, x: Tensor, units: number,\n      activation: ((x: Tensor) => Tensor)|null = null, useBias = true,\n      kernelInitializer: Initializer = new VarianceScalingInitializer(),\n      biasInitializer: Initializer = new ZerosInitializer()) {\n    const weights = this.g.variable(\n        name + '-weights',\n        kernelInitializer.initialize([x.shape[0], units], x.shape[0], units));\n\n    let out = this.g.matmul(x, weights);\n\n    if (useBias) {\n      const bias = this.g.variable(\n          name + '-bias',\n          biasInitializer.initialize([units], x.shape[0], units));\n      out = this.g.add(out, bias);\n    }\n\n    if (activation != null) {\n      out = activation(out);\n    }\n\n    return out;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as dataset from './dataset';\nimport {Graph, Tensor} from './graph';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArrayMathCPU} from './math/math_cpu';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {CostReduction, FeedEntry, Session} from './session';\n\nconst DEFAULT_EVAL_INTERVAL_MS = 1500;\nconst DEFAULT_COST_INTERVAL_MS = 500;\nconst DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000;\n\nexport interface GraphRunnerEventObserver {\n  batchesTrainedCallback?: (totalBatchesTrained: number) => void;\n  avgCostCallback?: (avgCost: Scalar) => void;\n  metricCallback?: (metric: NDArray) => void;\n  inferenceExamplesCallback?:\n      (feeds: FeedEntry[][], inferenceValues: NDArray[]) => void;\n  inferenceExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  trainExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  totalTimeCallback?: (totalTimeSec: number) => void;\n  doneTrainingCallback?: () => void;\n}\n\nexport enum MetricReduction {\n  SUM,\n  MEAN\n}\n\n/**\n * A class that drives the training of a graph model given a dataset. It allows\n * the user to provide a set of callbacks for measurements like cost, accuracy,\n * and speed of training.\n */\nexport class GraphRunner {\n  private costTensor: Tensor;\n  private trainFeedEntries: FeedEntry[];\n  private batchSize: number;\n  private optimizer: Optimizer;\n  private currentTrainLoopNumBatches: number|undefined;\n  private costIntervalMs: number;\n\n  private metricTensor: Tensor|undefined;\n  private metricFeedEntries: FeedEntry[]|undefined;\n  private metricBatchSize: number|undefined;\n  private metricReduction: MetricReduction;\n  private metricIntervalMs: number;\n\n  private inferenceTensor: Tensor;\n  private inferenceFeedEntries: FeedEntry[]|undefined;\n  private inferenceExampleIntervalMs: number;\n  private inferenceExampleCount: number;\n\n  // Runtime information.\n  private isTraining: boolean;\n  private totalBatchesTrained: number;\n  private batchesTrainedThisRun: number;\n  private lastComputedMetric: NDArray;\n\n  private isInferring: boolean;\n  private currentInferenceLoopNumPasses: number|undefined;\n  private inferencePassesThisRun: number;\n\n  private trainStartTimestamp: number;\n  private lastCostTimestamp = 0;\n  private lastEvalTimestamp = 0;\n\n  private lastStopTimestamp: number|null;\n  private totalIdleTimeMs = 0;\n\n  private zeroScalar: Scalar;\n  private metricBatchSizeScalar: Scalar;\n\n  constructor(\n      private math: NDArrayMath, private session: Session,\n      private eventObserver: GraphRunnerEventObserver) {\n    this.resetStatistics();\n    this.zeroScalar = Scalar.new(0);\n  }\n\n  resetStatistics() {\n    this.totalBatchesTrained = 0;\n    this.totalIdleTimeMs = 0;\n    this.lastStopTimestamp = null;\n  }\n\n  /**\n   * Start the training loop with an optional number of batches to train for.\n   * Optionally takes a metric tensor and feed entries to compute periodically.\n   * This can be used for computing accuracy, or a similar metric.\n   */\n  train(\n      costTensor: Tensor, trainFeedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, numBatches?: number, metricTensor?: Tensor,\n      metricFeedEntries?: FeedEntry[], metricBatchSize?: number,\n      metricReduction = MetricReduction.MEAN,\n      evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS,\n      costIntervalMs = DEFAULT_COST_INTERVAL_MS) {\n    this.costTensor = costTensor;\n    this.trainFeedEntries = trainFeedEntries;\n    this.metricTensor = metricTensor;\n    this.metricFeedEntries = metricFeedEntries;\n    if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) {\n      if (this.metricBatchSizeScalar != null) {\n        this.metricBatchSizeScalar.dispose();\n      }\n      this.metricBatchSizeScalar = Scalar.new(metricBatchSize);\n    }\n    this.metricBatchSize = metricBatchSize;\n    this.metricReduction = metricReduction;\n    this.batchSize = batchSize;\n    this.optimizer = optimizer;\n\n    this.metricIntervalMs = evalIntervalMs;\n    this.costIntervalMs = costIntervalMs;\n    this.currentTrainLoopNumBatches = numBatches;\n\n    this.batchesTrainedThisRun = 0;\n    this.isTraining = true;\n    this.trainStartTimestamp = performance.now();\n    this.trainNetwork();\n  }\n\n  stopTraining() {\n    this.isTraining = false;\n    this.lastStopTimestamp = performance.now();\n  }\n\n  resumeTraining() {\n    this.isTraining = true;\n    if (this.lastStopTimestamp != null) {\n      this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp;\n    }\n    this.trainNetwork();\n  }\n\n  private trainNetwork() {\n    if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) {\n      this.stopTraining();\n    }\n\n    if (!this.isTraining) {\n      if (this.eventObserver.doneTrainingCallback != null) {\n        this.eventObserver.doneTrainingCallback();\n      }\n      return;\n    }\n\n    const start = performance.now();\n    const shouldComputeCost = this.eventObserver.avgCostCallback != null &&\n        (start - this.lastCostTimestamp > this.costIntervalMs);\n    if (shouldComputeCost) {\n      this.lastCostTimestamp = start;\n    }\n\n    const costReduction =\n        shouldComputeCost ? CostReduction.MEAN : CostReduction.NONE;\n\n    this.math.scope((keep) => {\n      const avgCost = this.session.train(\n          this.costTensor, this.trainFeedEntries, this.batchSize,\n          this.optimizer, costReduction);\n\n      if (shouldComputeCost) {\n        const trainTime = performance.now() - start;\n\n        this.eventObserver.avgCostCallback!(avgCost);\n\n        if (this.eventObserver.trainExamplesPerSecCallback != null) {\n          const examplesPerSec = (this.batchSize * 1000 / trainTime);\n          this.eventObserver.trainExamplesPerSecCallback(examplesPerSec);\n        }\n      }\n\n      if (this.eventObserver.metricCallback != null &&\n          this.metricFeedEntries != null &&\n          start - this.lastEvalTimestamp > this.metricIntervalMs) {\n        this.lastEvalTimestamp = start;\n\n        if (this.lastComputedMetric != null) {\n          this.lastComputedMetric.dispose();\n        }\n        this.lastComputedMetric = this.computeMetric();\n        this.eventObserver.metricCallback(this.lastComputedMetric);\n      }\n\n      if (this.eventObserver.totalTimeCallback != null) {\n        this.eventObserver.totalTimeCallback(\n            (start - this.trainStartTimestamp) / 1000);\n      }\n\n      this.batchesTrainedThisRun++;\n      this.totalBatchesTrained++;\n\n      if (this.eventObserver.batchesTrainedCallback != null) {\n        this.eventObserver.batchesTrainedCallback(this.totalBatchesTrained);\n      }\n\n    });\n    setTimeout(() => this.trainNetwork());\n  }\n\n  infer(\n      inferenceTensor: Tensor, inferenceFeedEntries: FeedEntry[],\n      inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS,\n      inferenceExampleCount = 5, numPasses?: number) {\n    if (this.eventObserver.inferenceExamplesCallback == null &&\n        this.eventObserver.inferenceExamplesPerSecCallback == null) {\n      throw new Error(\n          'Cannot start inference loop, no inference example or ' +\n          'examples/sec observer provided.');\n    }\n\n    // Make sure the feed values are providers, and not NDArrays.\n    for (let i = 0; i < inferenceFeedEntries.length; i++) {\n      const feedEntry = inferenceFeedEntries[i];\n\n      if (feedEntry.data instanceof NDArray) {\n        throw new Error(\n            'Cannot start inference on the model runner with feed entries of ' +\n            'type NDArray. Please use InputProviders.');\n      }\n    }\n\n    this.inferenceExampleIntervalMs = inferenceExampleIntervalMs;\n    this.inferenceTensor = inferenceTensor;\n    this.inferenceFeedEntries = inferenceFeedEntries;\n    this.inferenceExampleCount = inferenceExampleCount;\n    this.currentInferenceLoopNumPasses = numPasses;\n    if (!this.isInferring) {\n      this.inferencePassesThisRun = 0;\n      setTimeout(() => this.inferNetwork());\n    }\n    this.isInferring = true;\n  }\n\n  private inferNetwork() {\n    if (!this.isInferring ||\n        this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) {\n      return;\n    }\n\n    this.math.scope((keep, track) => {\n      const feeds: FeedEntry[][] = [];\n      const inferenceValues: NDArray[] = [];\n\n      const start = performance.now();\n      for (let i = 0; i < this.inferenceExampleCount; i++) {\n        // Populate a new FeedEntry[] populated with NDArrays.\n        const ndarrayFeedEntries: FeedEntry[] = [];\n        for (let j = 0; j < this.inferenceFeedEntries!.length; j++) {\n          const feedEntry = this.inferenceFeedEntries![j];\n          ndarrayFeedEntries.push({\n            tensor: feedEntry.tensor,\n            data:\n                track((feedEntry.data as InputProvider).getNextCopy(this.math))\n          });\n        }\n        feeds.push(ndarrayFeedEntries);\n\n        inferenceValues.push(\n            this.session.eval(this.inferenceTensor, ndarrayFeedEntries));\n      }\n\n      if (this.eventObserver.inferenceExamplesPerSecCallback != null) {\n        // Force a GPU download, since inference results are generally needed on\n        // the CPU and it's more fair to include blocking on the GPU to complete\n        // its work for the inference measurement.\n        inferenceValues[inferenceValues.length - 1].getValues();\n\n        const inferenceExamplesPerSecTime = performance.now() - start;\n\n        const examplesPerSec =\n            (this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime);\n        this.eventObserver.inferenceExamplesPerSecCallback!(examplesPerSec);\n      }\n\n      if (this.eventObserver.inferenceExamplesCallback != null) {\n        this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues);\n      }\n      this.inferencePassesThisRun++;\n\n    });\n    setTimeout(() => this.inferNetwork(), this.inferenceExampleIntervalMs);\n  }\n\n  stopInferring() {\n    this.isInferring = false;\n  }\n\n  isInferenceRunning(): boolean {\n    return this.isInferring;\n  }\n\n  computeMetric(): Scalar {\n    if (this.metricFeedEntries == null) {\n      throw new Error('Cannot compute metric, no metric FeedEntries provided.');\n    }\n\n    let metric = this.zeroScalar;\n\n    return this.math.scope((keep) => {\n      for (let i = 0; i < this.metricBatchSize!; i++) {\n        const metricValue =\n            this.session.eval(this.metricTensor!, this.metricFeedEntries!);\n\n        metric = this.math.add(metric, metricValue);\n      }\n\n      if (this.metricReduction === MetricReduction.MEAN) {\n        metric = this.math.divide(metric, this.metricBatchSizeScalar);\n      }\n\n      return metric;\n    });\n  }\n\n  getTotalBatchesTrained(): number {\n    return this.totalBatchesTrained;\n  }\n\n  getLastComputedMetric(): Scalar {\n    return this.lastComputedMetric;\n  }\n\n  setMath(math: NDArrayMath) {\n    this.math = math;\n  }\n\n  setSession(session: Session) {\n    this.session = session;\n  }\n\n  setInferenceTensor(inferenceTensor: Tensor) {\n    this.inferenceTensor = inferenceTensor;\n  }\n\n  setInferenceExampleCount(inferenceExampleCount: number) {\n    this.inferenceExampleCount = inferenceExampleCount;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Graph, Node, PlaceholderNode, Tensor, VariableNode} from './graph';\nimport * as priority_queue from './priority_queue';\nimport {PriorityQueue} from './priority_queue';\nimport {TensorArrayMap} from './tensor_array_map';\n\n/**\n * Given a target node in a graph, accumulate the set of all nodes that need to\n * be evaluated in order to evaluate the target graph. Traversal stops anywhere\n * a node's values are fed in externally via \"feed dicts\".\n * @param nodes The nodes to be evaluated.\n * @param terminatingNodes The set of nodes that stop traversal.\n * @return The unordered set of nodes that need to be evaluated.\n */\nexport function getUnorderedEvaluationSet(\n    nodes: Node[], terminatingNodes: Node[]): Node[] {\n  const terminatingNodeMap: {[id: number]: Node} = {};\n  const seen: {[id: number]: Node} = {};\n  const set: Node[] = [];\n  const visit: Node[] = nodes.slice();\n  terminatingNodes.forEach(node => terminatingNodeMap[node.id] = node);\n  /* Flood fill: While the 'to visit' stack is not empty, pop a node off of it.\n   * If the node has not yet been visited, add it to the set, mark it as seen,\n   * and enqueue all of its ancestor (input) nodes. */\n  while (visit.length !== 0) {\n    const cur = visit.pop()!;\n    if (seen[cur.id] == null) {\n      if (terminatingNodeMap[cur.id] == null) {\n        Object.keys(cur.inputs)\n            .map(inputName => cur.inputs[inputName])\n            .forEach(input => visit.push(input.node));\n      }\n      set.push(cur);\n      seen[cur.id] = cur;\n    }\n  }\n  return set;\n}\n\n/**\n * Given a set of nodes, compute their order such that all dependent nodes are\n * evaluated after their dependees. This is the 'inference order' for nodes in\n * the operation graph.\n * @param unorderedEvaluationSet The unordered set of nodes that need to be\n * evaluated.\n * @return The input nodes in forward evaluation order.\n */\nexport function getOrderedEvaluationSet(unorderedEvaluationSet: Node[]):\n    Node[] {\n  /* A priority queue is used, where the priority is the remaining number of\n   * unevaluated nodes whose inputs come from the element node. This guarantees\n   * that all downstream nodes will be dequeued before their ancestors. */\n  const set: Node[] = [];\n  const nodeIndices: {[id: number]: number} = {};\n  const pendingDependencies: {[id: number]: number} = {};\n\n  /* The queue priority callback looks at the number of pending dependencies of\n   * a given node. The queue index observer callback maintains the location of\n   * each node in the array, for priority updates. */\n  const nodeQueue = new PriorityQueue<Node>(\n      (a: Node, b: Node) => priority_queue.defaultCompare(\n          pendingDependencies[a.id], pendingDependencies[b.id]),\n      (node: Node, newIndex: number) => nodeIndices[node.id] = newIndex);\n\n  unorderedEvaluationSet.forEach(node => pendingDependencies[node.id] = 0);\n\n  /* For every descendent of a node (output of ancestor is input to descendant),\n   * increment the 'pending dependency count' for the ancestor. This prepares\n   * the 'pending dependency count' as a priority map. */\n  unorderedEvaluationSet.forEach(\n      node => Object.keys(node.inputs)\n                  .map(key => node.inputs[key])\n                  .forEach(input => {\n                    if (unorderedEvaluationSet.indexOf(input.node) !== -1) {\n                      pendingDependencies[input.node.id]++;\n                    }\n                  }));\n\n  unorderedEvaluationSet.forEach(node => nodeQueue.enqueue(node));\n\n  while (!nodeQueue.empty()) {\n    set.unshift(nodeQueue.dequeue());\n    /* As each node is visited, decrement the 'pending dependency count' of\n     * each ancestor, and tell the priority queue that the priority has changed.\n     */\n    Object.keys(set[0].inputs).map(key => set[0].inputs[key]).forEach(input => {\n      if (unorderedEvaluationSet.indexOf(input.node) === -1) {\n        return;\n      }\n      pendingDependencies[input.node.id]--;\n      nodeQueue.update(input.node, nodeIndices[input.node.id]);\n    });\n  }\n\n  return set;\n}\n\n/**\n * @return True iff the node is an input node.\n */\nexport function isInputNode(node: Node): boolean {\n  return Object.keys(node.inputs).length === 0;\n}\n\nexport function shouldBackProp(t: Tensor): boolean {\n  return !(t.node instanceof ConstantNode);\n}\n\nexport function isPassthroughNode(node: Node, map: TensorArrayMap): boolean {\n  const keys = Object.keys(node.inputs);\n  for (let i = 0; i < keys.length; i++) {\n    const input = node.inputs[keys[i]];\n    if (map.get(input, true) === map.get(node.output, true)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from './math/conv_util';\nimport * as gpgpu_util from './math/webgl/gpgpu_util';\nimport * as render_ndarray_gpu_util from './math/webgl/render_ndarray_gpu_util';\nimport * as webgl_util from './math/webgl/webgl_util';\nimport * as util from './util';\n\nexport {CheckpointLoader} from './checkpoint_loader';\nexport {DataStats, InMemoryDataset} from './dataset';\nexport {Graph, Tensor} from './graph';\nexport {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner';\nexport {ConstantInitializer, Initializer, NDArrayInitializer, OnesInitializer, RandomNormalInitializer, RandomTruncatedNormalInitializer, RandomUniformInitializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nexport {InCPUMemoryShuffledInputProviderBuilder, InGPUMemoryShuffledInputProviderBuilder, InputProvider} from './input_provider';\nexport {MatrixOrientation, NDArrayMath} from './math/math';\nexport {NDArrayMathCPU} from './math/math_cpu';\nexport {NDArrayMathGPU} from './math/math_gpu';\nexport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './math/ndarray';\nexport {GPGPUContext} from './math/webgl/gpgpu_context';\nexport {Optimizer} from './optimizer';\nexport {CostReduction, FeedEntry, Session} from './session';\nexport {SGDOptimizer} from './sgd_optimizer';\n// Second level exports.\nexport {conv_util, gpgpu_util, render_ndarray_gpu_util, util, webgl_util};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * Initializer interface, all initializer implement this interface.\n */\nexport interface Initializer {\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray;\n}\n\nexport class VarianceScalingInitializer implements Initializer {\n  constructor(\n      private scale = 1.0,\n      private mode: 'fan_in'|'fan_out'|'fan_avg' = 'fan_in',\n      private distribution: 'uniform'|'normal' = 'normal') {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    let n = 0;\n    if (this.mode === 'fan_in') {\n      n = inputUnits;\n    } else if (this.mode === 'fan_out') {\n      n = outputUnits;\n    } else if (this.mode === 'fan_avg') {\n      n = (inputUnits + outputUnits) / 2;\n    } else {\n      throw new Error(\n          'Unexpected mode for variance scaling initializer: ' + this.mode);\n    }\n\n    if (this.distribution === 'normal') {\n      return NDArray.randTruncatedNormal(\n          weightsShape, 0.0, Math.sqrt(this.scale / n));\n    } else if (this.distribution === 'uniform') {\n      return NDArray.randUniform(\n          weightsShape, 0.0, Math.sqrt(3 * this.scale / n));\n    } else {\n      throw new Error(\n          'Unexpected distribution for variance scaling initializer: ' +\n          this.distribution);\n    }\n  }\n}\n\nexport class ZerosInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.zeros(weightsShape);\n  }\n}\n\nexport class OnesInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(1);\n    return values;\n  }\n}\n\nexport class ConstantInitializer implements Initializer {\n  constructor(private value = 0) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(this.value);\n    return values;\n  }\n}\n\nexport class NDArrayInitializer implements Initializer {\n  constructor(private ndarray: NDArray) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return this.ndarray;\n  }\n}\n\nexport class RandomNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomTruncatedNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomUniformInitializer implements Initializer {\n  constructor(private minval = -.05, private maxval = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randUniform(weightsShape, this.minval, this.maxval);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * The interface for input providers.\n */\nexport interface InputProvider {\n  /**\n   * Get the next input as a copy. This is important because the data might\n   * get uploaded to the GPU and modify the original data.\n   * @param math NDArrayMath\n   */\n  getNextCopy(math: NDArrayMath): NDArray;\n  /**\n   * Dispose the input copy.\n   * @param math NDArrayMath\n   * @param copy The copy provided from getNextCopy\n   */\n  disposeCopy(math: NDArrayMath, copy: NDArray): void;\n}\n\n/**\n * A common interface for shuffled input provider builders. This returns\n * InputProviders that are synchronized.\n * @hidden\n */\nexport interface ShuffledInputProviderBuilder {\n  getInputProviders(): InputProvider[];\n}\n\n/**\n * @hidden\n */\nexport abstract class InMemoryShuffledInputProviderBuilder implements\n    ShuffledInputProviderBuilder {\n  protected shuffledIndices: Uint32Array;\n  protected numInputs: number;\n\n  protected idx = 0;\n  // Counter for how many times the current index has been called. Resets to 0\n  // when it reaches the number of inputs.\n  protected inputCounter = 0;\n  protected epoch = 0;\n\n  /**\n   * Constructs an `InMemoryShuffledInputProvider`. All of the inputs must be\n   * in memory.\n   * @param inputs All of the inputs, size: [number of inputs][number of\n   * examples].\n   */\n  constructor(protected inputs: NDArray[][]) {\n    this.shuffledIndices = util.createShuffledIndices(inputs[0].length);\n    this.numInputs = inputs.length;\n\n    // Make sure the number of examples in each input matches.\n    const numExamples = this.inputs[0].length;\n    for (let i = 0; i < this.numInputs; i++) {\n      util.assert(\n          this.inputs[i].length === numExamples,\n          'Number of examples must match across different inputs.');\n    }\n\n    // Make sure the shapes within inputs all match.\n    for (let i = 0; i < this.numInputs; i++) {\n      const inputShape = this.inputs[i][0].shape;\n      for (let j = 0; j < this.inputs[i].length; j++) {\n        util.assertShapesMatch(inputShape, this.inputs[i][j].shape);\n      }\n    }\n  }\n\n  protected getCurrentExampleIndex(): number {\n    const returnIdx = this.idx;\n\n    this.inputCounter++;\n    if (this.inputCounter >= this.numInputs) {\n      this.idx++;\n      this.inputCounter = 0;\n\n      if (this.idx >= this.inputs[0].length) {\n        this.idx = 0;\n        this.epoch++;\n      }\n    }\n    return returnIdx;\n  }\n\n  protected getNextInput(inputId: number): NDArray {\n    const currentExampleIndex = this.getCurrentExampleIndex();\n\n    return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]];\n  }\n\n  getEpoch() {\n    return this.epoch;\n  }\n\n  /**\n   * Returns input providers which shuffle the inputs and stay in sync.\n   */\n  getInputProviders(): InputProvider[] {\n    const inputProviders: InputProvider[] = [];\n\n    for (let i = 0; i < this.numInputs; i++) {\n      inputProviders.push(this.getInputProvider(i));\n    }\n    return inputProviders;\n  }\n\n  abstract getInputProvider(inputId: number): InputProvider;\n}\n\n/**\n * An in CPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * CPU and keeps them mutually in sync.\n */\nexport class InCPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return NDArray.like(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n\n/**\n * An in GPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * GPU and keeps them mutually in sync. This is more performant than the CPU\n * version as textures will stay in memory, however this is more GPU memory\n * intensive as it keeps textures resident in GPU memory.\n */\nexport class InGPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return math.clone(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/** A node's activation function and its derivative. */\nexport interface ActivationFunction {\n  output<T extends NDArray>(math: NDArrayMath, input: T): T;\n  der<T extends NDArray>(math: NDArrayMath, input: T, output: T): T;\n}\n\nexport class TanHFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.tanh(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      const ySquared = math.elementWiseMul(y, y);\n      // 1 - y^2.\n      return math.scalarMinusArray(Scalar.ONE, ySquared);\n    });\n  }\n}\n\nexport class ReLUFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.relu(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      return math.step(x);\n    });\n  }\n}\n\nexport class SigmoidFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.sigmoid(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // y * (1 - y) = y - y^2\n      const ySquared = math.elementWiseMul(y, y);\n      return math.sub(y, ySquared);\n    });\n  }\n}\n\nexport class SquareFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.elementWiseMul(x, x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // dy/dx = 2*x.\n      return math.scalarTimesArray(Scalar.TWO, x);\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function assertConcat3DShapesMatch(\n    x1Shape: number[], x2Shape: number[], axis: number,\n    errorMessagePrefix = '') {\n  util.assert(\n      x1Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.');\n  util.assert(\n      x2Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.');\n\n  util.assert(\n      axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.');\n\n  for (let i = 0; i < 3; i++) {\n    util.assert(\n        (i === axis) || (x1Shape[i] === x2Shape[i]),\n        errorMessagePrefix +\n            `Shape (${x1Shape}) does not match (${x2Shape}) along ` +\n            `non-concatenated axis.`);\n  }\n}\n\nexport function computeConcat3DOutputShape(\n    x1Shape: number[], x2Shape: number[],\n    axis: number): [number, number, number] {\n  util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.');\n  util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.');\n\n  const outputShape = x1Shape.slice();\n  outputShape[axis] += x2Shape[axis];\n  return outputShape as [number, number, number];\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function computeOutputShape3D(\n    inputShapeRowColDepth: [number, number, number], fieldSize: number,\n    depth: number, stride: number, zeroPad?: number): [number, number, number] {\n  if (zeroPad == null) {\n    zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride);\n  }\n  const inputRows = inputShapeRowColDepth[0];\n  const inputCols = inputShapeRowColDepth[1];\n  const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputRows),\n      `The output # of rows (${outputRows}) must be an integer. Change the ` +\n          `stride and/or zero pad parameters`);\n\n  const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputCols),\n      `The output # of columns (${outputCols}) must be an integer. Change ` +\n          `the stride and/or zero pad parameters`);\n\n  return [outputRows, outputCols, depth];\n}\n\nexport function computeDefaultPad(\n    inputShape: [number, number, number], fieldSize: number,\n    stride: number): number {\n  return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2);\n}\n\nexport function computeTexShapeFrom3D(\n    shapeRowColDepth: [number, number, number]): [number, number] {\n  return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]];\n}\n\nexport function computeWeightsShape4D(\n    inputDepth: number, outputDepth: number,\n    fSize: number): [number, number, number, number] {\n  return [fSize, fSize, inputDepth, outputDepth];\n}\n\nexport function computeWeightsTexShape(\n    inputDepth: number, outputDepth: number,\n    fieldSize: number): [number, number] {\n  return [fieldSize * fieldSize * inputDepth, outputDepth];\n}\n\nexport function computeBiasesTexShape(outputDepth: number): [number, number] {\n  return [1, outputDepth];\n}\n\nexport function computeDilatedRC(\n    rc: [number, number], origStride: number): [number, number] {\n  const rowsDilated = (rc[0] - 1) * origStride + 1;\n  const colsDilated = (rc[1] - 1) * origStride + 1;\n  return [rowsDilated, colsDilated];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function validateShapes(\n    sourceSize: [number, number], destSize: [number, number]) {\n  const srcArea = sourceSize[0] * sourceSize[1];\n  const dstArea = destSize[0] * destSize[1];\n  if (srcArea !== dstArea) {\n    const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']';\n    const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']';\n    throw new Error(\n        'copy2D shapes have different areas:\\n  sourceSize ' + srcStr +\n        ', area ' + srcArea + '\\n  destSize ' + dstStr + ', area ' + dstArea);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/**\n * An error function and its derivative.\n */\nexport interface ElementWiseCostFunction {\n  cost<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  der<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  dispose(): void;\n}\n\nexport class SquareCostFunc implements ElementWiseCostFunction {\n  private halfOne = Scalar.new(0.5);\n\n  cost(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    const diff = math.sub(x1, x2);\n    const diffSquared = math.elementWiseMul(diff, diff);\n    const result = math.scalarTimesArray(this.halfOne, diffSquared);\n\n    diff.dispose();\n    diffSquared.dispose();\n\n    return result;\n  }\n\n  der(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    return math.sub(x1, x2);\n  }\n\n  dispose() {\n    this.halfOne.dispose();\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2d_util from './copy2d_util';\n\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport type ScopeResult = NDArray[]|NDArray|void;\n\nexport abstract class NDArrayMath {\n  private ndarrayScopes: NDArray[][] = [];\n  private activeScope: NDArray[];\n\n  private ndarraysToKeep: NDArray[][] = [];\n  private activeScopeNDArraysToKeep: NDArray[] = [];\n\n  /**\n   * @param safeMode In safe mode, you must use math operations inside\n   * a math.scope() which will automatically clean up intermediate NDArrays.\n   */\n  constructor(private safeMode: boolean) {}\n\n  /**\n   * Create a new math scope. Put chained math operations inside a scope\n   * function closure so that the library automatically cleans up NDArrays\n   * from intermediate math operations. You must create a scope in safe mode\n   * to call math operations. If a result is returned from the scope, it will\n   * also be tracked, which means there must be yet another wrapping scope.\n   * @param scopeFn The function to execute with chained math operations.\n   */\n  scope<T extends ScopeResult>(\n      scopeFn:\n          (keep: <T1 extends NDArray>(ndarray: T1) => T1,\n           track: <T2 extends NDArray>(ndarray: T2) => T2) => T) {\n    this.startScope();\n\n    const keepFn = <T extends NDArray>(ndarray: T): T => this.keep(ndarray);\n    const trackFn = <T extends NDArray>(ndarray: T): T => this.track(ndarray);\n    const result = scopeFn(keepFn, trackFn);\n\n    this.endScope(result);\n\n    return result;\n  }\n\n  /**\n   * Start a scope. Use this with endScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  startScope() {\n    const newScope: NDArray[] = [];\n    this.ndarrayScopes.push(newScope);\n    this.activeScope = newScope;\n\n    const newNDArraysToKeep: NDArray[] = [];\n    this.ndarraysToKeep.push(newNDArraysToKeep);\n    this.activeScopeNDArraysToKeep = newNDArraysToKeep;\n  }\n\n  /**\n   * End a scope. Use this with startScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  endScope(result: ScopeResult) {\n    // Dispose the current scope.\n    for (let i = 0; i < this.activeScope.length; i++) {\n      const ndarray = this.activeScope[i];\n\n      if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) ||\n          (result != null && result instanceof NDArray &&\n           ndarray.getData() === (result as NDArray).getData())) {\n        continue;\n      }\n      ndarray.dispose();\n    }\n\n    // Pop the current scope.\n    this.ndarrayScopes.pop();\n    this.activeScope = this.ndarrayScopes.length === 0 ?\n        null! :\n        this.ndarrayScopes[this.ndarrayScopes.length - 1];\n\n    // Track the current result in the parent scope.\n    if (result instanceof NDArray &&\n        !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) {\n      this.track(result);\n    } else if (Array.isArray(result)) {\n      result.forEach(r => {\n        if (r instanceof NDArray &&\n            !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) {\n          this.track(r);\n        }\n      });\n    }\n\n    this.ndarraysToKeep.pop();\n    this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ?\n        null! :\n        this.ndarraysToKeep[this.ndarraysToKeep.length - 1];\n  }\n\n  private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) {\n    for (let i = 0; i < ndarrayList.length; i++) {\n      if (ndarrayList[i].getData() === ndarray.getData()) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Keeps an NDArray in the current scope from being disposed automatically.\n   * @param result The NDArray to keep from being disposed.\n   */\n  keep<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScopeNDArraysToKeep.push(result);\n    return result;\n  }\n\n  /**\n   * Tracks an NDArray in the current scope to be automatically cleaned up when\n   * the current scope ends, and returns the value.\n   * @param result The NDArray to track in the current scope.\n   */\n  track<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScope.push(result);\n    return result;\n  }\n\n  /**\n   * Computes the dot product of two matrices, A * B. These must be matrices,\n   * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct\n   * in other cases.\n   * @param a First matrix in dot product operation.\n   * @param b Second matrix in dot product operation.\n   * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will\n   * compute A^T * B.\n   * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will\n   * compute A * B^T.\n   */\n  matMul(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const innerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const innerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1];\n\n    util.assert(\n        a.rank === 2 && b.rank === 2,\n        `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` +\n            `and ${b.rank}.`);\n\n    util.assert(\n        innerShapeA === innerShapeB,\n        `Error in matMul: inner shapes (${innerShapeA}) and (` +\n            `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` +\n            `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` +\n            ` and ${MatrixOrientation[bOrientation]} must match.`);\n\n    return this.track(this.matMulInternal(a, b, aOrientation, bOrientation));\n  }\n  protected abstract matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D;\n\n  /**\n   * Computes the dot product of a vector and a matrix, v * B.\n   * @param v The vector in dot product operation.\n   * @param matrix The matrix in dot product operation.\n   */\n  vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: first input must be rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: second input must be rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[0],\n        `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `rank ${matrix.rank}.`);\n\n    return this.matMul(v.as2D(1, v.size), matrix).as1D();\n  }\n\n  /**\n   * Computes the dot product of a matrix and vector, A * v.\n   * @param matrix The matrix in dot product operation.\n   * @param v The vector in dot product operation.\n   */\n  matrixTimesVector(matrix: Array2D, v: Array1D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: second input must rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: first input must be a rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[1],\n        `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `shape ${matrix.shape}.`);\n\n    return this.matMul(matrix, v.as2D(v.size, 1)).as1D();\n  }\n\n  /**\n   * Computes the dot product of two vectors, v1 * v2.\n   * @param v1 The first vector in the dot product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  dotProduct(v1: Array1D, v2: Array1D): Scalar {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in dotProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n    util.assert(\n        v1.size === v2.size,\n        `Error in dotProduct: size of inputs (${v1.size}) and (` +\n            `${v2.size}) must match.`);\n    return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar();\n  }\n\n  /**\n   * Computes the outer product of two vectors, v1 and v2.\n   * @param v1 The first vector in the outer product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  outerProduct(v1: Array1D, v2: Array1D): Array2D {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in outerProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n\n    return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size));\n  }\n\n  ///////////////\n  // Shape ops //\n  ///////////////\n\n  /**\n   * Clones an NDArray of any shape.\n   * @param ndarray The NDArray to clone.\n   */\n  clone<T extends NDArray>(ndarray: T): T {\n    return this.track(this.cloneInternal(ndarray));\n  }\n  protected abstract cloneInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Reshapes an NDArray to a new shape. The size of the input NDArray must\n   * match the size of the requested shape.\n   * @param ndarray The input NDArray.\n   * @param newShape The new shape to reshape the NDArray to. Must be the same\n   * size as the NDArray.\n   */\n  reshape<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    util.assert(\n        ndarray.size === util.sizeFromShape(newShape),\n        `Error in reshape: old size ${ndarray.size} must match new size ` +\n            `${util.sizeFromShape(newShape)}.`);\n    return this.track(this.reshapeInternal<T1, T2>(ndarray, newShape));\n  }\n  protected abstract reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2;\n\n  /**\n   * Extracts a slice from a matrix. The operation extraces a slice from input\n   * that starts at coordinates `begin` and is of size `size`.\n   * @param input The input matrix to slice from.\n   * @param begin The 2D coordinates in the input matrix to start the slice\n   * from.\n   * @param size The sice of the 2D window to slice.\n   */\n  slice2D(input: Array2D, begin: [number, number], size: [number, number]):\n      Array2D {\n    util.assert(\n        begin[0] + size[0] <= input.shape[0] &&\n            begin[1] + size[1] <= input.shape[1],\n        `Error in slice2D: requested start position ${begin} and size ` +\n            `${size} would overflow input of shape ${input.shape}.`);\n    return this.track(this.slice2DInternal(input, begin, size));\n  }\n  protected abstract slice2DInternal(\n      input: Array2D, begin: [number, number], size: [number, number]): Array2D;\n\n  /**\n   * Copies a window from the `source` matrix starting at `sourceBegin` and is\n   * of size `sourceSize` to a window in the `dest` matrix starting at\n   * `destBegin` and is of size `destSize`/\n   * @param source The source matrix to copy from.\n   * @param sourceBegin The coordinates to start the copy from.\n   * @param sourceSize The size of the copy window.\n   * @param dest The destination matrix to copy to.\n   * @param destBegin The coordinates in `dest` to copy to.\n   * @param destSize The size of the destination window.\n   */\n  copy2D(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]) {\n    util.assert(\n        sourceBegin[0] + sourceSize[0] <= source.shape[0] &&\n            sourceBegin[1] + sourceSize[1] <= source.shape[1],\n        `Error in copy2D: requested source start position ${sourceBegin} ` +\n            `and source size ${sourceSize} would overflow source NDArray` +\n            `of shape ${source.shape}.`);\n    util.assert(\n        destBegin[0] + destSize[0] <= dest.shape[0] &&\n            destBegin[1] + destSize[1] <= dest.shape[1],\n        `Error in copy2D: requested dest start position ${destBegin} ` +\n            `and source size ${destSize} would overflow dest NDArray of` +\n            `shape ${dest.shape}.`);\n    copy2d_util.validateShapes(sourceSize, destSize);\n\n    return this.copy2DInternal(\n        source, sourceBegin, sourceSize, dest, destBegin, destSize);\n  }\n  protected abstract copy2DInternal(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]): void;\n\n  /**\n   * Concatenates two 3D ndarrays along a given axis.\n   *\n   * For example, if:\n   * A: shape(2, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *\n   * B: shape(2, 1, 3) = | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * C = concat3D(A, B, axis)\n   *\n   * if axis = 0:\n   * C: shape(4, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *                     | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * if axis = 1:\n   * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |\n   *                     | r2, g2, b2, r4, g4, b4 |\n   *\n   * if axis = 2:\n   * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |\n   *                      | r2, g2, b2, r4, g4, b4 |\n   *\n   * @param ndarray1 The first array to concat.\n   * @param ndarray2 The second array to conat.\n   * @param axis The axis to concate along.\n   */\n  concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D {\n    concat3d_util.assertConcat3DShapesMatch(\n        ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: ');\n    return this.track(this.concat3DInternal(ndarray1, ndarray2, axis));\n  }\n  protected abstract concat3DInternal(\n      ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D;\n\n  ///////////////////\n  // Reduction ops //\n  ///////////////////\n\n  /**\n   * Computes the the log(sum(e ^ x)) for each x in the input ndarray.\n   * @param ndarray The input NDArray to compute the logSumExp over.\n   */\n  logSumExp(ndarray: NDArray): Scalar {\n    return this.track(this.logSumExpInternal(ndarray));\n  }\n  protected abstract logSumExpInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the sum of all the entries in the input NDArray.\n   * @param ndarray The input NDArray to compute the sum over.\n   */\n  sum(ndarray: NDArray): Scalar {\n    return this.track(this.sumInternal(ndarray));\n  }\n  protected abstract sumInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the minimum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMin(ndarray: NDArray): Scalar {\n    return this.track(this.argMinInternal(ndarray));\n  }\n  protected abstract argMinInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the maximum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMax(ndarray: NDArray): Scalar {\n    return this.track(this.argMaxInternal(ndarray));\n  }\n  protected abstract argMaxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0.\n   * @param x1 The first input NDArray.\n   * @param x2 The second input NDArray.\n   */\n  argMaxEquals(x1: NDArray, x2: NDArray): Scalar {\n    util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: ');\n    return this.track(this.argMaxEqualsInternal(x1, x2));\n  }\n  protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar;\n\n  /**\n   * Computes the top K values and flattened indices.\n   * @param ndarray The input NDArray.\n   * @param k How many top values to compute.\n   */\n  topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} {\n    util.assert(\n        k <= ndarray.size,\n        `Error in topK: k value (${k}) must be less than size of input ` +\n            `ndarray, got shape ${ndarray.shape}.`);\n    const result = this.topKInternal(ndarray, k);\n    this.track(result.values);\n    this.track(result.indices);\n    return result;\n  }\n  protected abstract topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D};\n\n  /**\n   * Computes the minimum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  min(ndarray: NDArray): Scalar {\n    return this.track(this.minInternal(ndarray));\n  }\n  protected abstract minInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the maximum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  max(ndarray: NDArray): Scalar {\n    return this.track(this.maxInternal(ndarray));\n  }\n  protected abstract maxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the softmax normalized vector from the input vector.\n   * @param x The input vector.\n   */\n  softmax(x: Array1D): Array1D {\n    return this.scope(() => {\n      // Do it in log space for numerical stability.\n      // exp(X - logSumExp(X))\n      const lse = this.logSumExp(x);\n      const logResult = this.arrayMinusScalar(x, lse);\n      return this.exp(logResult);\n    });\n  }\n\n  //////////////////////\n  // Element-wise ops //\n  //////////////////////\n\n  /**\n   * Switches dimensions of the input NDArray.\n   * @param a The input NDArray.\n   * @param newDim The new indices that define which shapes values to switch.\n   */\n  switchDim<T extends NDArray>(a: T, newDim: number[]): T {\n    util.assert(\n        a.rank === newDim.length,\n        `Error in switchDim: length of input shape ${a.shape} ` +\n            `must match size of newDim array ${newDim}.`);\n    return this.track(this.switchDimInternal(a, newDim));\n  }\n  protected abstract switchDimInternal<T extends NDArray>(\n      a: T, newDim: number[]): T;\n\n  /**\n   * Computes a scalar plus NDArray, c + A.\n   * @param c The scalar c in c + A.\n   * @param a The NDArray A in c + A.\n   */\n  scalarPlusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarPlusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarPlusArrayInternal(c, a));\n  }\n  protected abstract scalarPlusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, c - A.\n   * @param c The scalar c in c - A.\n   * @param a The NDArray A in c - A.\n   */\n  scalarMinusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarMinusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarMinusArrayInternal(c, a));\n  }\n  protected abstract scalarMinusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, A - c.\n   * @param a The NDArray A in A - c.\n   * @param c The scalar c in A - c.\n   */\n  arrayMinusScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayMinusScalar: second argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.arrayMinusScalarInternal(a, c));\n  }\n  protected abstract arrayMinusScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes -1 * A element-wise.\n   * @param a The input array.\n   */\n  neg<T extends NDArray>(a: T): T {\n    return this.track(this.negInternal(a));\n  }\n  protected abstract negInternal<T extends NDArray>(a: T): T;\n\n  /**\n   * Adds two NDArrays element-wise, A + B. Inputs must be the same shape.\n   * @param a The first NDArray to add element-wise.\n   * @param b The second NDArray to add element-wise.\n   */\n  add<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in add: ');\n    return this.track(this.addInternal(a, b));\n  }\n  protected abstract addInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape.\n   * @param a The first NDArray to subtract element-wise.\n   * @param b The second NDArray to subtract element-wise.\n   */\n  sub<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in sub: ');\n    return this.track(this.subInternal(a, b));\n  }\n  protected abstract subInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must\n   * be the same shape.\n   * @param a The first NDArray to multiply element-wise.\n   * @param b The second NDArray to multiply element-wise.\n   */\n  elementWiseMul<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: ');\n    return this.track(this.elementWiseMulInternal(a, b));\n  }\n  protected abstract elementWiseMulInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be\n   * the same shape.\n   * @param a The first NDArray to divide element-wise.\n   * @param b The second NDArray to divide element-wise.\n   */\n  divide<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in divide: ');\n    return this.track(this.divideInternal(a, b));\n  }\n  protected abstract divideInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c /\n   * A.\n   * @param c The scalar value in c / A.\n   * @param a The NDArray value in c / A.\n   */\n  scalarDividedByArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarDividedByArray: first argument must be rank 0, but ` +\n            `got NDArray of rank ${c.rank}.`);\n    return this.track(this.scalarDividedByArrayInternal(c, a));\n  }\n  protected abstract scalarDividedByArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A /\n   * c.\n   * @param a The NDArray value in A / c.\n   * @param c The scalar value in A / c.\n   */\n  arrayDividedByScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: second argument must be rank 0, ` +\n            `but got NDArray of rank ${c.rank}.`);\n    return this.track(this.arrayDividedByScalarInternal(a, c));\n  }\n  protected abstract arrayDividedByScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes exponential of the input NDArray element-wise. y = e ^ x\n   * @param ndarray The input NDArray.\n   */\n  exp<T extends NDArray>(ndarray: T): T {\n    return this.track(this.expInternal(ndarray));\n  }\n  protected abstract expInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes natural logarithm of the input NDArray element-wise. y = ln(x)\n   * @param ndarray The input NDArray.\n   */\n  log<T extends NDArray>(ndarray: T): T {\n    return this.track(this.logInternal(ndarray));\n  }\n  protected abstract logInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes rectified linear element-wise, max(x, 0).\n   * @param ndarray The input NDArray.\n   */\n  relu<T extends NDArray>(ndarray: T): T {\n    return this.track(this.reluInternal(ndarray));\n  }\n  protected abstract reluInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)).\n   * @param ndarray The input NDArray.\n   */\n  sigmoid<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sigmoidInternal(ndarray));\n  }\n  protected abstract sigmoidInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes hyperbolic tangent of the input NDArray element-wise.\n   * @param ndarray The input NDArray.\n   */\n  tanh<T extends NDArray>(ndarray: T): T {\n    return this.track(this.tanhInternal(ndarray));\n  }\n  protected abstract tanhInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sin of the input NDArray element-wise, y = sin(x).\n   * @param ndarray The input NDArray.\n   */\n  sin<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sinInternal(ndarray));\n  }\n  protected abstract sinInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <=\n   * 0\n   * @param ndarray The input NDArray.\n   */\n  step<T extends NDArray>(ndarray: T): T {\n    return this.track(this.stepInternal(ndarray));\n  }\n  protected abstract stepInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes a scaled array add operation, c1 * A + c2 * B.\n   * @param c1 The first scalar in the scaled array add computation.\n   * @param a The first NDArray in the scaled array add computation.\n   * @param c2 The second scalar in the scaled array add computation.\n   * @param cb The second NDArray in the scaled array add computation.\n   */\n  scaledArrayAdd<T extends NDArray>(c1: Scalar, a: T, c2: Scalar, b: T): T {\n    util.assert(\n        c1.size === 1,\n        `Error in scaledArrayAdd: first argument must rank 0, but got ` +\n            ` rank ${c1.rank}.`);\n    util.assert(\n        c2.size === 1,\n        `Error in scaledArrayAdd: third argument must be rank 0, but got ` +\n            `NDArray of rank ${c2.rank}.`);\n    util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: ');\n\n    return this.track(this.scaledArrayAddInternal(c1, a, c2, b));\n  }\n  protected abstract scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T): T;\n\n  /**\n   * Computes a scalar times array operation broadcasted over the NDArray, c *\n   * A.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  scalarTimesArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: first argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.scalarTimesArrayInternal(c, a));\n  }\n  protected abstract scalarTimesArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an element-wise broadcasted multiplication of two matrices A and\n   * B. Will return a new matrix that is the max of A and B, where the smaller\n   * matrix will broadcast over the larger matrix.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D {\n    util.assert(\n        a.rank === 2,\n        `Error in elementWiseMulBroadcast: first argument must be ` +\n            `rank 2, but got rank ${a.rank}.`);\n    util.assert(\n        b.rank === 2,\n        `Error in elementWiseMulBroadcast: second argument must be ` +\n            `rank 2, but got rank ${b.rank}.`);\n    return this.track(this.elementWiseMulBroadcastInternal(a, b));\n  }\n  protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D):\n      Array2D;\n\n  /////////////////////\n  // Convolution ops //\n  /////////////////////\n\n  /**\n   * Computes a 2D convolution over the input x.\n   * @param x The input image, must be rank 3, of shape [rows, cols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param zeroPad The zero padding of each side of the input NDArray. Will pad\n   * equally on all sides.\n   */\n  conv2d(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2d: weights must be rank 4, but got rank ` +\n            `${weights.rank}.`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2d: biases must be rank 1, but got rank ` +\n              `${biases.rank}.`);\n    }\n\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2d: depth of input (${x.shape[2]}) must match  ` +\n            `input depth for weights ${weights.shape[2]}.`);\n\n\n    return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad));\n  }\n  protected abstract conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D;\n\n  /**\n   * Computes the backprop of a 2D convolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param stride The stride of the original convolution.\n   * @param pad The padding of the original convolution.\n   */\n  conv2dBackProp(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dBackProp: x must be rank 3, but got shape ` +\n            `${x.shape}.`);\n    util.assert(\n        dy.rank === 3,\n        `Error in conv2dBackProp: dy must be rank 3, but got shape ` +\n            `${dy.shape}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dBackProp: weights must be rank 4, but got shape ` +\n            `${weights.shape}.`);\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` +\n            `match input depth for weights (${weights.shape[2]}.`);\n    util.assert(\n        dy.shape[2] === weights.shape[3],\n        `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` +\n            `match output depth for weights (${weights.shape[3]}).`);\n\n    const backpropResult =\n        this.conv2dBackPropInternal(x, dy, weights, stride, pad);\n\n    this.track(backpropResult.db);\n    this.track(backpropResult.dw);\n    this.track(backpropResult.dx);\n\n    return backpropResult;\n  }\n  protected abstract conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D};\n\n  /**\n   * Computes the transposed 2D convolution of an image, also known as a\n   * deconvolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  conv2dTranspose(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dTranspose: x must be rank 3, but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dTranspose: weights must be rank 4, but got ` +\n            `rank ${weights.rank}`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2dTranspose: biases must be rank 1, but got ' +\n              'rank ${biases.rank}.`);\n    }\n    util.assert(\n        x.shape[2] === weights.shape[3],\n        `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` +\n            `match input depth for weights ${weights.shape[3]}.`);\n\n    return this.track(\n        this.conv2dTransposeInternal(x, weights, biases, stride, pad));\n  }\n  protected abstract conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D max pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.');\n    return this.track(this.maxPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the backprop of a max pool.\n   * @param dy The dy error.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPoolBackprop(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        dy.rank === 3,\n        `Error in maxPoolBackprop: dy must be rank 3 but got rank ` +\n            `${dy.rank}.`);\n    util.assert(\n        x.rank === 3,\n        `Error in maxPoolBackprop: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n\n    return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad));\n  }\n  protected abstract maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D min pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in minPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.minPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the 2D average pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.avgPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /*\n   * Bilinear resize a 3D array per each channel to a new 2D shape.\n   * @param x The input Array3D.\n   * @param newShape2D The new shape to resize the Array3D to. Each channel is\n   * resized individually.\n   * @param alignCorners An optional bool. Defaults to False. If true, rescale\n   * input by (new_height - 1) / (height - 1), which exactly aligns the 4\n   * corners of images and resized images. If false, rescale by new_height /\n   * height. Treat similarly the width dimension.\n   */\n  resizeBilinear3D(\n      x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`);\n    util.assert(\n        newShape2D.length === 2,\n        `Error in resizeBilinear3D: new shape must 2D, but got shape ` +\n            `${newShape2D}.`);\n    return this.track(\n        this.resizeBilinear3DInternal(x, newShape2D, alignCorners));\n  }\n  protected abstract resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D;\n\n  /**\n   * Batch normalization 3D. Mean, variance, scale, and offset can be of two\n   * shapes: 1) The same shape as the input: an Array3D. 2) In the common case,\n   * the depth dimension is the last dimension of x, so the values would be an\n   * Array1D of shape [depth].\n   * @param x The input NDArray.\n   * @param mean A mean NDArray.\n   * @param variance A variance NDArray.\n   * @param varianceEpsilon A small float number to avoid dividing by 0.\n   * @param scale A scale NDArray.\n   * @param offset An offset NDArray.\n   */\n  batchNormalization3D(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in batchNormalization3D: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        mean.rank === 3 || mean.rank === 1,\n        `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` +\n            `got rank ${mean.rank}.`);\n    util.assert(\n        variance.rank === 3 || variance.rank === 1,\n        `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` +\n            `but got rank ${variance.rank}.`);\n    if (scale != null) {\n      util.assert(\n          scale.rank === 3 || scale.rank === 1,\n          `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` +\n              `but got rank ${scale!.rank}.`);\n    }\n    if (offset != null) {\n      util.assert(\n          offset.rank === 3 || offset.rank === 1,\n          `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` +\n              `but got rank ${offset!.rank}.`);\n    }\n\n    return this.track(this.batchNormalization3DInternal(\n        x, mean, variance, varianceEpsilon, scale, offset));\n  }\n  protected abstract batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D;\n}\n\nexport enum MatrixOrientation {\n  REGULAR,\n  TRANSPOSED\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../math/conv_util';\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2D_util from './copy2d_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport class NDArrayMathCPU extends NDArrayMath {\n  constructor(safeMode = false) {\n    super(safeMode);\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    return NDArray.make<T>(\n        ndarray.shape, {values: new Float32Array(ndarray.getValues())});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    return this.cloneInternal(ndarray).reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = Array2D.zeros(sizeRowCol);\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol);\n    const srcValues = source.getValues();\n    const dstValues = dest.getValues();\n    const n = sourceSizeRowCol[0] * sourceSizeRowCol[1];\n    for (let i = 0; i < n; ++i) {\n      const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]);\n      const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]);\n      const srcOff = srcRow * source.shape[1] + srcCol;\n      const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]);\n      const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]);\n      const dstOff = dstRow * dest.shape[1] + dstCol;\n      dstValues[dstOff] = srcValues[srcOff];\n    }\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const outputShape =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const values = NDArray.zeros<Array3D>(outputShape);\n\n    for (let i = 0; i < outputShape[0]; i++) {\n      for (let j = 0; j < outputShape[1]; j++) {\n        for (let k = 0; k < outputShape[2]; k++) {\n          // Shader begins.\n          const index: [number, number, number] = [i, j, k];\n          let value: number;\n          if (index[axis] < x1.shape[axis]) {\n            value = x1.get(i, j, k);\n          } else {\n            index[axis] -= x1.shape[axis];\n            const [i2, j2, k2] = index;\n            value = x2.get(i2, j2, k2);\n          }\n\n          values.set(value, i, j, k);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const resultValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < resultValues.length; ++i) {\n      resultValues[i] = cVal + aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: resultValues});\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    const cValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    const c1Val = c1.get();\n    const c2Val = c2.get();\n    for (let i = 0; i < cValues.length; ++i) {\n      cValues[i] = c1Val * aValues[i] + c2Val * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: cValues});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cVal * aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const negA = this.negInternal(a);\n    const result = this.scalarPlusArrayInternal(c, negA);\n\n    negA.dispose();\n\n    return result;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    const negC = this.negInternal(c);\n    const result = this.scalarPlusArrayInternal(negC, a);\n\n    negC.dispose();\n\n    return result;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a);\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.ONE, b);\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.NEG_ONE, b);\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n\n    const leftDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const rightDim =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n\n    const normalGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(i, j);\n    const transposedGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(j, i);\n\n    const aGetter = (aOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const bGetter = (bOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const values = new Float32Array(leftDim * rightDim);\n    let index = 0;\n\n    for (let i = 0; i < leftDim; ++i) {\n      for (let j = 0; j < rightDim; ++j) {\n        let sum = 0;\n        for (let k = 0; k < sharedDim; ++k) {\n          // TODO: optimize CPU matmul.\n          sum += aGetter(a, i, k) * bGetter(b, k, j);\n        }\n        values[index++] = sum;\n      }\n    }\n    return Array2D.new([leftDim, rightDim], values);\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    const maxRow = Math.max(a.shape[0], b.shape[0]);\n    const maxCol = Math.max(a.shape[1], b.shape[1]);\n\n    const values = new Float32Array(maxRow * maxCol);\n    let index = 0;\n    for (let row = 0; row < maxRow; row++) {\n      for (let col = 0; col < maxCol; col++) {\n        values[index++] = a.get(row % a.shape[0], col % a.shape[1]) *\n            b.get(row % b.shape[0], col % b.shape[1]);\n      }\n    }\n    return Array2D.new([maxRow, maxCol], values);\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cValue / aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / cValue;\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    let sum = 0;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      sum += values[i];\n    }\n    return Scalar.new(sum);\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    let min = Number.MAX_VALUE;\n    let minIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n        minIndex = i;\n      }\n    }\n    return Scalar.new(minIndex);\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    let max = Number.NEGATIVE_INFINITY;\n    let maxIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n    return Scalar.new(maxIndex);\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    const argMax1 = this.argMaxInternal(x1).get();\n    const argMax2 = this.argMaxInternal(x2).get();\n    if (isNaN(argMax1) || isNaN(argMax2)) {\n      return Scalar.new(NaN);\n    }\n    return Scalar.new(+(argMax1 === argMax2));\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    const values = ndarray.getValues();\n    const valuesAndIndices: Array<{value: number, index: number}> = [];\n    for (let i = 0; i < values.length; i++) {\n      valuesAndIndices.push({value: values[i], index: i});\n    }\n    valuesAndIndices.sort((a, b) => {\n      return b.value - a.value;\n    });\n    const topkValues = new Float32Array(k);\n    const topkIndices = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n      topkValues[i] = valuesAndIndices[i].value;\n      topkIndices[i] = valuesAndIndices[i].index;\n    }\n    return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)};\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let min = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n      }\n    }\n    return Scalar.new(min);\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let max = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n      }\n    }\n    return Scalar.new(max);\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      newValues[i] = Math.exp(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      newValues[i] = Math.log(value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const xMax = this.max(ndarray);\n    const a = this.arrayMinusScalar(ndarray, xMax);\n    const b = this.exp(a);\n    const c = this.sum(b);\n    const d = this.log(c);\n    const result = this.add(xMax, d);\n\n    xMax.dispose();\n    a.dispose();\n    b.dispose();\n    c.dispose();\n    d.dispose();\n\n    return result;\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.max(0, values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = 1 / (1 + Math.exp(-values[i]));\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = util.tanh(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.sin(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    const [xRows, xCols, inputDepth] = x.shape;\n    const fieldSize = weights.shape[0];\n    const outputDepth = weights.shape[3];\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fieldSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fieldSize + xCCorner);\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              for (let d1 = 0; d1 < inputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight = weights.get(wR, wC, d1, d2);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = (biases != null) ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad);\n    return {dx, db, dw};\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const fSize = weights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR - pad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / origStride));\n        const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride);\n\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC - pad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / origStride));\n          const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride);\n\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR * origStride - xRCorner;\n\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC * origStride - xCCorner;\n\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = biases != null ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeShaderLike(\n      x: Array3D, origWeights: Array4D, origStride: number,\n      origPad: number): Array3D {\n    const fSize = origWeights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = origWeights.shape[2];\n    const origOutputDepth = origWeights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          // Shader code begins.\n          const xRCorner = yR - pad;\n          const xCCorner = yC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const xR = (xRCorner + wR) / origStride;\n            if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const xC = (xCCorner + wC) / origStride;\n              if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) {\n                continue;\n              }\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          y.set(dotProd, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    const dW = Array4D.zeros(weightsShape);\n\n    const yNumRows = dY.shape[0];\n    const yNumCols = dY.shape[1];\n    const xNumRows = x.shape[0];\n    const xNumCols = x.shape[1];\n\n    for (let wR = 0; wR < fSize; ++wR) {\n      const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride));\n      const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride);\n\n      for (let wC = 0; wC < fSize; ++wC) {\n        const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride));\n        const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride);\n\n        for (let d1 = 0; d1 < inputDepth; ++d1) {\n          for (let d2 = 0; d2 < outputDepth; ++d2) {\n            // Need to convolve.\n            let dotProd = 0;\n            for (let yR = yRMin; yR < yRMax; ++yR) {\n              const xR = wR + yR * stride - zeroPad;\n              for (let yC = yCMin; yC < yCMax; ++yC) {\n                const xC = wC + yC * stride - zeroPad;\n                dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2);\n              }\n            }\n            dW.set(dotProd, wR, wC, d1, d2);\n          }\n        }\n      }\n    }\n    return dW;\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const numRows = dY.shape[0];\n    const numCols = dY.shape[1];\n    const values = new Float32Array(outputDepth);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      let sum = 0;\n      for (let r = 0; r < numRows; ++r) {\n        for (let c = 0; c < numCols; ++c) {\n          sum += dY.get(r, c, d2);\n        }\n      }\n      values[d2] = sum;\n    }\n    return Array1D.new(values);\n  }\n\n  protected switchDimInternal<T extends NDArray>(t: T, newDim: number[]): T {\n    const newShape: number[] = new Array(t.rank);\n    for (let i = 0; i < newShape.length; i++) {\n      newShape[i] = t.shape[newDim[i]];\n    }\n    const resultValues = new Float32Array(t.size);\n    const values = t.getValues();\n    const result = NDArray.make<T>(newShape, {values: resultValues});\n    for (let i = 0; i < t.size; ++i) {\n      const loc = t.indexToLoc(i);\n\n      // Permute location.\n      const newLoc: number[] = new Array(loc.length);\n      for (let i = 0; i < newLoc.length; i++) {\n        newLoc[i] = loc[newDim[i]];\n      }\n\n      const newIndex = result.locToIndex(newLoc);\n      resultValues[newIndex] = values[i];\n    }\n    return result;\n  }\n\n  private pool(\n      x: Array3D, fSize: number, stride: number, pad: number,\n      poolType: 'max'|'min'|'avg') {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, depth], fSize, depth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n\n\n          let minMaxValue =\n              (poolType === 'max' ? Number.NEGATIVE_INFINITY :\n                                    Number.POSITIVE_INFINITY);\n          let avgValue = 0;\n\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (isNaN(pixel)) {\n                minMaxValue = NaN;\n                avgValue = NaN;\n                break;\n              }\n              if ((poolType === 'max' && pixel > minMaxValue) ||\n                  (poolType === 'min' && pixel < minMaxValue)) {\n                minMaxValue = pixel;\n              } else if (poolType === 'avg') {\n                avgValue += pixel / (fSize * fSize);\n              }\n            }\n            if (isNaN(minMaxValue)) {\n              break;\n            }\n          }\n          y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'max');\n  }\n\n  maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad);\n    const maxPositions = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < outputShape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < outputShape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n          let maxValue = Number.NEGATIVE_INFINITY;\n          let maxPosition = -1;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (pixel > maxValue) {\n                maxValue = pixel;\n                maxPosition = wR * fSize + wC;\n              }\n            }\n          }\n          maxPositions.set(maxPosition, yR, yC, d);\n        }\n      }\n    }\n    return maxPositions;\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad);\n    const pad = fSize - 1 - origPad;\n    const [dyRows, dyCols, depth] = dy.shape;\n\n    // Dilate the input.\n    const dyRowsDilated = (dyRows - 1) * origStride + 1;\n    const dxColsDilated = (dyCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad);\n    const dx = Array3D.zeros(outputShape);\n\n    for (let d = 0; d < depth; ++d) {\n      for (let dxR = 0; dxR < dx.shape[0]; ++dxR) {\n        for (let dxC = 0; dxC < dx.shape[1]; ++dxC) {\n          // Shader code begins.\n          const dyRCorner = dxR - pad;\n          const dyCCorner = dxC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const dyR = (dyRCorner + wR) / origStride;\n            if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const dyC = (dyCCorner + wC) / origStride;\n              if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) {\n                continue;\n              }\n              const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d);\n              const curPos = wR * fSize + wC;\n\n              const mask = maxPos === curPos ? 1 : 0;\n              if (mask === 0) {\n                continue;\n              }\n\n              const pixel = dy.get(dyR, dyC, d);\n              dotProd += pixel * mask;\n            }\n          }\n          dx.set(dotProd, dxR, dxC, d);\n        }\n      }\n    }\n    return dx;\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'min');\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'avg');\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]);\n\n    const effectiveInputSize =\n        alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape;\n    const effectiveOutputSize = alignCorners ?\n        [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] :\n        output.shape;\n    for (let r = 0; r < output.shape[0]; r++) {\n      for (let c = 0; c < output.shape[1]; c++) {\n        for (let d = 0; d < output.shape[2]; d++) {\n          // Begin shader.\n\n          // Compute the fractional index of the source.\n          const sourceFracRow =\n              (effectiveInputSize[0]) * r / (effectiveOutputSize[0]);\n          const sourceFracCol =\n              (effectiveInputSize[1]) * c / (effectiveOutputSize[1]);\n\n          const sourceRowFloor = Math.floor(sourceFracRow);\n          const sourceRowCeil =\n              Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow));\n          const sourceColFloor = Math.floor(sourceFracCol);\n          const sourceColCeil =\n              Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol));\n\n          const topLeft = x.get(sourceRowFloor, sourceColFloor, d);\n          const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d);\n          const topRight = x.get(sourceRowFloor, sourceColCeil, d);\n          const bottomRight = x.get(sourceRowCeil, sourceColCeil, d);\n\n          const rowFrac = sourceFracRow - sourceRowFloor;\n          const colFrac = sourceFracCol - sourceColFloor;\n\n          const top = topLeft + (topRight - topLeft) * colFrac;\n          const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;\n          const newValue = top + (bottom - top) * rowFrac;\n\n          output.set(newValue, r, c, d);\n        }\n      }\n    }\n\n    return output;\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xValues = x.getValues();\n    const meanValues = mean.getValues();\n    const varianceValues = variance.getValues();\n    const scaleValues = scale ? scale.getValues() : new Float32Array([1]);\n    const offsetValues = offset ? offset.getValues() : new Float32Array([0]);\n    const outValues = new Float32Array(xValues.length);\n\n    for (let i = 0; i < xValues.length; i++) {\n      outValues[i] = offsetValues[i % offsetValues.length] +\n          (xValues[i] - meanValues[i % meanValues.length]) *\n              scaleValues[i % scaleValues.length] /\n              Math.sqrt(\n                  varianceValues[i % varianceValues.length] + varianceEpsilon);\n    }\n    return NDArray.make<Array3D>(x.shape, {values: outValues});\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as conv_util from './conv_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport * as ndarray from './ndarray';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\nimport * as addscaledmat_gpu from './webgl/addscaledmat_gpu';\nimport * as addsubmuldiv_gpu from './webgl/addsubmuldiv_gpu';\nimport {OperandType} from './webgl/addsubmuldiv_gpu';\nimport * as argmaxequals_gpu from './webgl/argmaxequals_gpu';\nimport * as argminmax_gpu from './webgl/argminmax_gpu';\nimport * as avg_pool_gpu from './webgl/avg_pool_gpu';\nimport * as batchnorm_gpu from './webgl/batchnorm_gpu';\nimport * as concat3d_gpu from './webgl/concat3d_gpu';\nimport * as conv_backprop_gpu from './webgl/conv_backprop_gpu';\nimport * as conv_gpu from './webgl/conv_gpu';\nimport * as copy_gpu from './webgl/copy_gpu';\nimport * as exp_gpu from './webgl/exp_gpu';\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport * as gpgpu_util from './webgl/gpgpu_util';\nimport * as log_gpu from './webgl/log_gpu';\nimport * as logsumexp_gpu from './webgl/logsumexp_gpu';\nimport * as max_pool_backprop_gpu from './webgl/max_pool_backprop_gpu';\nimport * as max_pool_gpu from './webgl/max_pool_gpu';\nimport * as min_pool_gpu from './webgl/min_pool_gpu';\nimport * as minmax_gpu from './webgl/minmax_gpu';\nimport * as mulmat_gpu from './webgl/mulmat_gpu';\nimport * as neg_gpu from './webgl/neg_gpu';\nimport * as pool_gpu from './webgl/pool_gpu';\nimport * as reducesum_gpu from './webgl/reducesum_gpu';\nimport * as relu_gpu from './webgl/relu_gpu';\nimport * as reshape_gpu from './webgl/reshape_gpu';\nimport * as resize_bilinear_gpu from './webgl/resize_bilinear_gpu';\nimport * as shader_compiler from './webgl/shader_compiler';\nimport * as sigmoid_gpu from './webgl/sigmoid_gpu';\nimport * as step_gpu from './webgl/step_gpu';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as trig_gpu from './webgl/trig_gpu';\nimport * as webgl_util from './webgl/webgl_util';\n\nconst ARGMAX_PROG = 'argmax';\nconst ARGMAX_EQUALS_PROG = 'argmaxequals';\nconst ARGMIN_PROG = 'argmin';\n\nconst BATCHNORM_PROG = 'batchnorm';\n\nconst COPY_PROG = 'copy';\nconst CONCAT_PROG = 'concat';\n\n// Matrix algebra.\nconst ADD_SCALED_MAT_PROG = 'addscaledmat';\nconst MATMUL_PROG = 'matmul';\n\n// Element-wise ops.\nconst RELU_PROG = 'relu';\nconst TANH_PROG = 'tanh';\nconst SIN_PROG = 'sin';\nconst SIGMOID_PROG = 'sigmoid';\nconst MAX_PROG = 'max';\nconst MIN_PROG = 'min';\nconst NEG_PROG = 'neg';\nconst EXP_PROG = 'exp';\nconst LOG_PROG = 'log';\nconst SUM_PROG = 'sum';\nconst STEP_PROG = 'step';\nconst LOGSUMEXP_PROG = 'logsumexp';\nconst RESHAPE_PROG = 'reshape';\nconst ADD_SUM_MUL_DIV_PROG = 'addsummuldiv';\n\n// Convolution.\nconst CONV2D_PROG = 'conv';\nconst CONV2D_TRANSPOSE_PROG = 'conv_transpose';\nconst CONV2D_DERW_PROG = 'conv_derw';\nconst CONV2D_DERB_PROG = 'conv_derb';\nconst MAX_POOL_PROG = 'maxpool';\nconst MAX_POOL_POSITIONS_PROG = 'maxpool_posn';\nconst MAX_POOL_BACKPROP_PROG = 'maxpool_backprop';\nconst MIN_POOL_PROG = 'minpool';\nconst AVG_POOL_PROG = 'avgpool';\n\nconst RESIZE_BILINEAR_PROG = 'resizebilin';\n\nfunction makeCopyProgramName(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  const shapeName = `${sourceShapeRowCol[0]}_${sourceShapeRowCol[1]}`;\n  const srcSizeName = `${sourceSizeRowCol[0]}_${sourceSizeRowCol[1]}`;\n  const dstSizeName = `${destSizeRowCol[0]}_${destSizeRowCol[1]}`;\n  return `${COPY_PROG}_${shapeName}_${srcSizeName}_${dstSizeName}`;\n}\n\nexport class NDArrayMathGPU extends NDArrayMath {\n  private gpgpu: GPGPUContext;\n  private textureManager: TextureManager;\n  private programCache: {[key: string]: WebGLProgram} = {};\n  private gpgpuCreatedLocally: boolean;\n\n  constructor(gpgpu?: GPGPUContext, safeMode = true) {\n    super(safeMode);\n    if (gpgpu == null) {\n      const gl = gpgpu_util.createWebGLContext();\n      this.gpgpu = new GPGPUContext(gl);\n      this.gpgpuCreatedLocally = true;\n    } else {\n      this.gpgpu = gpgpu;\n      this.gpgpuCreatedLocally = false;\n    }\n\n    this.textureManager = new TextureManager(this.gpgpu);\n\n    ndarray.initializeGPU(this.gpgpu, this.textureManager);\n  }\n\n  getGPGPUContext(): GPGPUContext {\n    return this.gpgpu;\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC),\n        () => copy_gpu.getFragmentShaderSource(\n            textureShapeRC, textureShapeRC, textureShapeRC));\n\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    copy_gpu.copy(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0],\n        textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    let newTexShape: [number, number];\n\n    switch (newShape.length) {\n      case 0:\n        newTexShape = [1, 1];\n        break;\n      case 1:\n        newTexShape = [newShape[0], 1];\n        break;\n      case 2:\n        newTexShape = [newShape[0], newShape[1]];\n        break;\n      case 3:\n        newTexShape = [newShape[0], newShape[1] * newShape[2]];\n        break;\n      default:\n        throw Error(\n            `Reshapes into ${newShape.length}-dim ndarray is not yet ` +\n            `supported on GPU`);\n    }\n\n    const actualTexShape = ndarray.getTextureShapeRC(newTexShape);\n    let clonedArray: T1;\n    if (!util.arraysEqual(actualTexShape, newTexShape)) {\n      clonedArray = this.reshapeTexture(ndarray, newTexShape);\n    } else {\n      clonedArray = this.cloneInternal(ndarray);\n    }\n    return clonedArray.reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = NDArray.make<Array2D>(sizeRowCol, {\n      texture: this.textureManager.acquireTexture(sizeRowCol),\n      textureShapeRC: sizeRowCol\n    });\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    const sourceShapeRC = source.getTextureShapeRC();\n    const destShapeRC = dest.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol),\n        () => copy_gpu.getFragmentShaderSource(\n            sourceShapeRC, sourceSizeRowCol, destSizeRowCol));\n\n    copy_gpu.copy(\n        this.gpgpu, program, source.getTexture(), sourceShapeRC,\n        sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC,\n        destBeginRowCol, destSizeRowCol);\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const x1TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x1.shape);\n    const x2TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x2.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC);\n    let cleanupX1 = false;\n    if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) {\n      x1 = this.reshapeTexture(x1, x1TexShapeRC);\n      cleanupX1 = true;\n    }\n    const actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC);\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) {\n      x2 = this.reshapeTexture(x2, x2TexShapeRC);\n      cleanupX2 = true;\n    }\n\n    const resultShapeRCD =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const program = this.getAndSaveProgram(\n        `${CONCAT_PROG}_${x1.shape}_${x2.shape}_${axis}`,\n        () => concat3d_gpu.getFragmentShaderSource(\n            x1.shape, x2.shape, resultShapeRCD, axis));\n\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    concat3d_gpu.concat3D(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX1) {\n      x1.dispose();\n    }\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '+', OperandType.MATRIX) as T;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    return this.addSubMulDiv(\n        a, c, a.shape, OperandType.MATRIX, '-', OperandType.SCALAR) as T;\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '-', OperandType.MATRIX) as T;\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    let cleanupB = false;\n    if (!this.doGPUShapesMatch(a, b)) {\n      b = this.reshapeTexture(b, a.getTextureShapeRC());\n      cleanupB = true;\n    }\n\n    const program = this.getAndSaveProgram(\n        ADD_SCALED_MAT_PROG, () => addscaledmat_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    addscaledmat_gpu.addScaledMatrices(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n    // Bring the result back to the original shape.\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '*', OperandType.MATRIX) as T;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    const program = this.getAndSaveProgram(\n        NEG_PROG, () => neg_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    neg_gpu.neg(\n        this.gpgpu, program, a.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  private reshapeTexture<T extends NDArray>(a: T, newTextureShape: [\n    number, number\n  ]): T {\n    const aTexShape = a.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        RESHAPE_PROG, () => reshape_gpu.getFragmentShaderSource());\n\n    const resultTexture = this.textureManager.acquireTexture(newTextureShape);\n    reshape_gpu.reshape(\n        this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1],\n        resultTexture, newTextureShape[0], newTextureShape[1]);\n\n    return NDArray.make<T>(\n        a.shape, {texture: resultTexture, textureShapeRC: newTextureShape});\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const outerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const outerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n    const outShape: [number, number] = [outerShapeA, outerShapeB];\n    const outTexShape =\n        webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape);\n    const outTexture = this.textureManager.acquireTexture(outTexShape);\n    const out = new Array2D(\n        outShape, {texture: outTexture, textureShapeRC: outTexShape});\n\n    const key = shader_compiler.makeShaderKey([a, b], out);\n    const program = this.getAndSaveProgram(\n        `${MATMUL_PROG}_${key}_${aOrientation}_${bOrientation}`,\n        () => mulmat_gpu.getFragmentShader(\n            a, b, out, aOrientation, bOrientation));\n\n    mulmat_gpu.multiplyMatrix(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture,\n        outTexShape);\n\n    return out;\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '*', OperandType.MATRIX) as T;\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xTexShape = x.getTextureShapeRC();\n\n    let cleanupMean = false;\n    const preferredMeanTexShape: [number, number] =\n        mean.rank === 1 ? [1, mean.size] : xTexShape;\n    let meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) {\n      mean = this.reshapeTexture(mean, preferredMeanTexShape);\n      meanTexShape = preferredMeanTexShape;\n      cleanupMean = true;\n    }\n\n    let cleanupVariance = false;\n    const preferredVarianceTexShape: [number, number] =\n        variance.rank === 1 ? [1, variance.size] : xTexShape;\n    let varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) {\n      variance = this.reshapeTexture(variance, preferredVarianceTexShape);\n      varianceTexShape = preferredVarianceTexShape;\n      cleanupVariance = true;\n    }\n\n    let scaleTexShape: [number, number]|null = null;\n    let cleanupScale = false;\n    if (scale != null) {\n      const preferredScaleTexShape: [number, number] =\n          scale.rank === 1 ? [1, scale.size] : xTexShape;\n\n      scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape);\n      if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) {\n        scale = this.reshapeTexture(scale, preferredScaleTexShape);\n        scaleTexShape = preferredScaleTexShape;\n        cleanupScale = true;\n      }\n    }\n\n    let offsetTexShape: [number, number]|null = null;\n    let cleanupOffset = false;\n    if (offset != null) {\n      const preferredOffsetTexShape: [number, number] =\n          offset.rank === 1 ? [1, offset.size] : xTexShape;\n\n      offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape);\n      if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) {\n        offset = this.reshapeTexture(offset, preferredOffsetTexShape);\n        offsetTexShape = preferredOffsetTexShape;\n        cleanupOffset = true;\n      }\n    }\n\n    const resultTexShape: [number, number] = x.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${BATCHNORM_PROG}_${xTexShape}_${meanTexShape}_${varianceTexShape}_` +\n            `${scaleTexShape!}_${offsetTexShape!}_${varianceEpsilon}`,\n        () => batchnorm_gpu.getFragmentShaderSource(\n            xTexShape, meanTexShape, varianceTexShape, offsetTexShape,\n            scaleTexShape, varianceEpsilon));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    batchnorm_gpu.batchNormalization(\n        this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(),\n        meanTexShape, variance.getTexture(), varianceTexShape,\n        offset != null ? offset.getTexture() : null,\n        offset != null ? offsetTexShape : null,\n        scale != null ? scale.getTexture() : null,\n        scale != null ? scaleTexShape : null, resultTexture, resultTexShape);\n\n    if (cleanupMean) {\n      mean.dispose();\n    }\n    if (cleanupVariance) {\n      variance.dispose();\n    }\n    if (cleanupScale) {\n      scale!.dispose();\n    }\n    if (cleanupOffset) {\n      offset!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        x.shape, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  protected switchDimInternal<T extends NDArray>(a: T, newDim: number[]): T {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${SUM_PROG}_${numRows}_${numColumns}`,\n        () => reducesum_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMIN_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    // If the texture shapes doesn't match, do a physical reshape so they do.\n    const actualX1TexShape = x1.getTextureShapeRC();\n    const actualX2TexShape = x2.getTextureShapeRC();\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) {\n      x2 = this.reshapeTexture(x2, actualX1TexShape);\n      cleanupX2 = true;\n    }\n\n    const textureShapeRC = x1.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_EQUALS_PROG}_${numRows}_${numColumns}`,\n        () => argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(\n            numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argmaxequals_gpu.argMaxEquals(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows,\n        numColumns, resultTexture);\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    throw new Error('topK GPU not yet implemented!');\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MIN_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MAX_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '/', OperandType.MATRIX) as T;\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    return this.addSubMulDiv(\n               c, a, a.shape, OperandType.SCALAR, '/', OperandType.MATRIX) as T;\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    return this.addSubMulDiv(\n               a, c, a.shape, OperandType.MATRIX, '/', OperandType.SCALAR) as T;\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '+', OperandType.MATRIX) as T;\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '-', OperandType.MATRIX) as T;\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const [numRows, numColumns] = ndarray.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${LOGSUMEXP_PROG}_${numRows}_${numColumns}`,\n        () => logsumexp_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const result =\n        new Scalar({texture: this.textureManager.acquireTexture([1, 1])});\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        result.getTexture());\n\n    return result;\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        EXP_PROG, () => exp_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    exp_gpu.exp(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        LOG_PROG, () => log_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n    log_gpu.log(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        RELU_PROG, () => relu_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    relu_gpu.relu(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIGMOID_PROG, () => sigmoid_gpu.getSigmoidFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    sigmoid_gpu.sigmoid(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        TANH_PROG, () => trig_gpu.getTanhFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.tanh(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIN_PROG, () => trig_gpu.getSinFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.sin(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        STEP_PROG, () => step_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    step_gpu.step(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    const fieldSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const progKey = [\n      CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_gpu.getFragmentShaderSource(\n          x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(outputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    const resultShape = conv_util.computeOutputShape3D(\n        x.shape, fieldSize, outputDepth, stride, zeroPad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_gpu.convolve(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB && biases != null) {\n      biases.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const yTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupX = false;\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dy.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dy = this.reshapeTexture(dy, yTexShape);\n      cleanupY = true;\n    }\n\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(\n        dy, weights, null /** biases */, stride, pad);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupY) {\n      dy.dispose();\n    }\n    return {dx, db, dw};\n  }\n\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const fieldSize = weights.shape[0];\n\n    const progKey = [\n      CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride,\n      origPad, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderConvTransposeSource(\n          x.shape, fieldSize, origInputDepth, origStride, origPad,\n          biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape = conv_util.computeWeightsTexShape(\n        origInputDepth, origOutputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(origInputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBiasTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    // Figure out the output shape by dilating the input.\n    const dilatedRC =\n        conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride);\n    const pad = fieldSize - 1 - origPad;\n    const resultShape = conv_util.computeOutputShape3D(\n        [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize,\n        origInputDepth, 1, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.convTranspose(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB) {\n      biases!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const progKey = [\n      CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerWeightsSource(\n          x.shape, fSize, outputDepth, stride, zeroPad);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const yShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, outputDepth, stride, zeroPad);\n    const yTexShape = conv_util.computeTexShapeFrom3D(yShape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derWeights(\n        this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    return NDArray.make<Array4D>(\n        weightsShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const progKey = [CONV2D_DERB_PROG, dY.shape].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape);\n    });\n    const yTexShape = conv_util.computeTexShapeFrom3D(dY.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape = conv_util.computeBiasesTexShape(outputDepth);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derBias(\n        this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape);\n\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    return NDArray.make<Array1D>(\n        [outputDepth], {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  private pool(\n      program: WebGLProgram, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    const resultShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const poolResultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    pool_gpu.poolCommon(\n        this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: poolResultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const maxPoolProgKey =\n        [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, () => {\n      return max_pool_gpu.getFragmentShaderMaxPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(maxPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const minPoolProgKey =\n        [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const minPoolProgram = this.getAndSaveProgram(minPoolProgKey, () => {\n      return min_pool_gpu.getFragmentShaderMinPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(minPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const avgPoolProgKey =\n        [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, () => {\n      return avg_pool_gpu.getFragmentShaderAvgPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(avgPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPoolPositionsProgKey = [\n      MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad\n    ].join('_');\n    const maxPoolPositionsProgram =\n        this.getAndSaveProgram(maxPoolPositionsProgKey, () => {\n          return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(\n              x.shape, fSize, origStride, origPad);\n        });\n\n    const maxPoolResultShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, x.shape[2], origStride, origPad);\n    const maxPoolResultTexShape =\n        conv_util.computeTexShapeFrom3D(maxPoolResultShape);\n    const maxPoolPositionsResultTex =\n        this.textureManager.acquireTexture(maxPoolResultTexShape);\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    max_pool_gpu.maxPoolCommon(\n        this.gpgpu, maxPoolPositionsProgram, x.getTexture(),\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    const maxPoolBackpropProgKey = [\n      MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad\n    ].join('_');\n    const program = this.getAndSaveProgram(maxPoolBackpropProgKey, () => {\n      return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(\n          dy.shape, fSize, origStride, origPad);\n    });\n\n    const dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualDyTexShape = dy.getTextureShapeRC(dyTexShape);\n    let cleanupDy = false;\n    if (!util.arraysEqual(actualDyTexShape, dyTexShape)) {\n      dy = this.reshapeTexture(dy, dyTexShape);\n      cleanupDy = true;\n    }\n\n    const dilatedDyRC =\n        conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride);\n    const pad = fSize - 1 - origPad;\n    const resultShapeRCD = conv_util.computeOutputShape3D(\n        [dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1,\n        pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    max_pool_backprop_gpu.maxPoolBackprop(\n        this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex,\n        resultTex, resultTexShape);\n\n    if (cleanupDy) {\n      dy.dispose();\n    }\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    this.textureManager.releaseTexture(\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const programKey =\n        [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_');\n\n    const newShapeRCD: [number, number, number] =\n        [newShape2D[0], newShape2D[1], x.shape[2]];\n    const resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD);\n\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => resize_bilinear_gpu.getFragmentShaderSource(\n            x.shape, newShape2D, alignCorners));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    resize_bilinear_gpu.resizeBilinear(\n        this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape);\n\n    return NDArray.make<Array3D>(\n        newShapeRCD, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  private getAndSaveProgram(programKey: string, getShaderSource: () => string):\n      WebGLProgram {\n    if (!(programKey in this.programCache)) {\n      this.programCache[programKey] =\n          this.gpgpu.createProgram(getShaderSource());\n    }\n    return this.programCache[programKey];\n  }\n\n  private addSubMulDiv(\n      a: NDArray, b: NDArray, resultShape: number[],\n      operandA: addsubmuldiv_gpu.OperandType,\n      opType: addsubmuldiv_gpu.Operation,\n      operandB: addsubmuldiv_gpu.OperandType): NDArray {\n    let cleanupB = false;\n\n    const aOrientation = MatrixOrientation.REGULAR;\n    let bOrientation = MatrixOrientation.REGULAR;\n\n    let logicalBTexShape: [number, number];\n\n    if (operandA === OperandType.MATRIX && operandB === OperandType.MATRIX) {\n      util.assertShapesMatch(a.shape, b.shape);\n\n      if (a.inGPU()) {\n        // Prefer B to have the shape of A.\n        b.getTextureShapeRC(a.getTextureShapeRC());\n      } else if (b.inGPU()) {\n        // Prefer A to have the shape of B.\n        a.getTextureShapeRC(b.getTextureShapeRC());\n      }\n\n      const aTexShape = a.getTextureShapeRC();\n      const bTexShape = b.getTextureShapeRC();\n      logicalBTexShape = bTexShape;\n\n      if (a.rank === 1) {\n        // When dealing with vectors, we can sample in transposed way without\n        // the need to do physical reshape.\n        if (!util.arraysEqual(bTexShape, aTexShape)) {\n          bOrientation = MatrixOrientation.TRANSPOSED;\n          logicalBTexShape = [bTexShape[1], bTexShape[0]];\n        }\n      }\n\n      if (!util.arraysEqual(aTexShape, logicalBTexShape)) {\n        b = this.reshapeTexture(b, aTexShape);\n        bOrientation = MatrixOrientation.REGULAR;\n        logicalBTexShape = b.getTextureShapeRC();\n        cleanupB = true;\n      }\n    } else {\n      logicalBTexShape = b.getTextureShapeRC();\n    }\n\n    const aTexShape = a.getTextureShapeRC();\n    const bTexShape = b.getTextureShapeRC();\n\n    const programKey = [\n      ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB,\n      bOrientation\n    ].join('_');\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => addsubmuldiv_gpu.getFragmentShaderSource(\n            operandA, aOrientation, opType, operandB, bOrientation));\n\n    const resultTextureShape: [number, number] = [\n      Math.max(aTexShape[0], logicalBTexShape[0]),\n      Math.max(aTexShape[1], logicalBTexShape[1])\n    ];\n\n    const resultTexture =\n        this.textureManager.acquireTexture(resultTextureShape);\n\n    addsubmuldiv_gpu.addSubMulDiv(\n        this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(),\n        bTexShape, resultTexture, resultTextureShape);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n\n    return NDArray.make(\n        resultShape,\n        {texture: resultTexture, textureShapeRC: resultTextureShape});\n  }\n\n  private doGPUShapesMatch(a: NDArray, b: NDArray): boolean {\n    util.assertShapesMatch(a.shape, b.shape);\n    if (a.inGPU()) {\n      // Prefer B to have the shape of A.\n      b.getTextureShapeRC(a.getTextureShapeRC());\n    } else if (b.inGPU()) {\n      // Prefer A to have the shape of B.\n      a.getTextureShapeRC(b.getTextureShapeRC());\n    }\n    return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC());\n  }\n\n  getTextureManager(): TextureManager {\n    return this.textureManager;\n  }\n\n  dispose() {\n    for (const programKey in this.programCache) {\n      if (this.programCache.hasOwnProperty(programKey)) {\n        this.gpgpu.deleteProgram(this.programCache[programKey]);\n      }\n    }\n    this.textureManager.dispose();\n\n    if (this.gpgpuCreatedLocally) {\n      this.gpgpu.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as webgl_util from './webgl/webgl_util';\n\n// These global variables need to be initialized to null so that closure knows\n// not to seal them.\n/** @hidden */\nexport let GPGPU: GPGPUContext = null!;\n/** @hidden */\nexport let TEXTURE_MANAGER: TextureManager = null!;\n\n/** @hidden */\nexport interface NDArrayData {\n  values?: Float32Array;\n  texture?: WebGLTexture;\n  /** [rows, columns] shape of the texture. */\n  textureShapeRC?: [number, number];\n}\n\n/** @hidden */\nexport function initializeGPU(\n    gpgpu: GPGPUContext, textureManager: TextureManager) {\n  GPGPU = gpgpu;\n  TEXTURE_MANAGER = textureManager;\n}\n\nfunction throwIfGPUNotInitialized() {\n  if (GPGPU == null || TEXTURE_MANAGER == null) {\n    throw new Error('GPU not intialized.');\n  }\n}\n\nexport class NDArray {\n  /** The shape of the ndarray. */\n  shape: number[];\n  /** Number of elements in the ndarray. */\n  size: number;\n\n  /**\n   * Number of elements to skip in each dimension when indexing. See\n   * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html\n   */\n  protected strides: number[];\n\n  private data: NDArrayData;\n\n  protected constructor(shape: number[], data: NDArrayData) {\n    // Sanity checks.\n    util.assert(\n        data.values != null || data.texture != null,\n        'Either `values` or `texture` must be defined');\n\n    util.assert(\n        data.texture == null || (data.textureShapeRC != null),\n        '`textureShape` must be defined when `texture` is defined');\n\n    this.size = util.sizeFromShape(shape);\n\n    if (data.values != null) {\n      util.assert(\n          this.size === data.values.length,\n          'Constructing ndarray of shape (' + this.size + ') should match the' +\n              ' length of values (' + data.values.length + ')');\n    }\n\n    this.shape = shape;\n    this.data = data;\n    const dim = this.shape.length;\n\n    if (dim < 2) {\n      this.strides = [];\n    } else {\n      // Last dimension has implicit stride of 1, thus having D-1 (instead of D)\n      // strides.\n      this.strides = new Array(dim - 1);\n      this.strides[dim - 2] = this.shape[dim - 1];\n      for (let i = dim - 3; i >= 0; --i) {\n        this.strides[i] = this.strides[i + 1] * this.shape[i + 1];\n      }\n    }\n  }\n\n  /** Creates a ndarray of zeros with the specified shape. */\n  static zeros<T extends NDArray>(shape: number[]): T {\n    const values = new Float32Array(util.sizeFromShape(shape));\n    return NDArray.make<T>(shape, {values});\n  }\n\n  /** Creates a ndarray of zeros with the same shape as the specified ndarray.\n   */\n  static zerosLike<T extends NDArray>(another: T): T {\n    return NDArray.zeros(another.shape) as T;\n  }\n\n  /** Creates a ndarray with the same values/shape as the specified ndarray. */\n  static like<T extends NDArray>(another: T): T {\n    const values = another.getValues();\n    return NDArray.make<T>(another.shape, {values: new Float32Array(values)});\n  }\n\n  /**\n   * Makes a new ndarray with the provided shape and values. Values should be in\n   * a flat array.\n   */\n  static make<T extends NDArray>(shape: number[], data: NDArrayData): T {\n    switch (shape.length) {\n      case 0:\n        return new Scalar(data) as T;\n      case 1:\n        // tslint:disable-next-line:no-any\n        return new Array1D(data) as any;\n      case 2:\n        // tslint:disable-next-line:no-any\n        return new Array2D(shape as [number, number], data) as any;\n      case 3:\n        // tslint:disable-next-line:no-any\n        return new Array3D(shape as [number, number, number], data) as any;\n      case 4:\n        return new Array4D(\n                   // tslint:disable-next-line:no-any\n                   shape as [number, number, number, number], data) as any;\n      default:\n        // tslint:disable-next-line:no-any\n        return new NDArray(shape, data) as any;\n    }\n  }\n\n  /** Reshapes the current ndarray into the provided shape. */\n  reshape<T extends NDArray>(newShape: number[]): T {\n    if (util.arraysEqual(this.shape, newShape)) {\n      // No-op.\n      // tslint:disable-next-line:no-any\n      return this as any;\n    }\n\n    util.assert(\n        this.size === util.sizeFromShape(newShape),\n        'new shape and old shape must have the same number of elements.');\n\n    return NDArray.make<T>(newShape, this.data);\n  }\n\n  asScalar(): Scalar {\n    util.assert(this.size === 1, 'The array must have only 1 element.');\n    return this.reshape<Scalar>([]);\n  }\n\n  as1D(): Array1D {\n    return this.reshape<Array1D>([this.size]);\n  }\n\n  as2D(rows: number, columns: number): Array2D {\n    return this.reshape<Array2D>([rows, columns]);\n  }\n\n  as3D(rows: number, columns: number, depth: number): Array3D {\n    return this.reshape<Array3D>([rows, columns, depth]);\n  }\n\n  as4D(rows: number, columns: number, depth: number, depth2: number): Array4D {\n    return this.reshape<Array4D>([rows, columns, depth, depth2]);\n  }\n\n  get rank(): number {\n    return this.shape.length;\n  }\n\n  get(...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return this.getValues()[index];\n  }\n\n  add(value: number, ...locs: number[]) {\n    this.set(this.get(...locs) + value, ...locs);\n  }\n\n  set(value: number, ...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    this.getValues()[index] = value;\n  }\n\n  locToIndex(locs: number[]): number {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return index;\n  }\n\n  indexToLoc(index: number): number[] {\n    const locs: number[] = new Array(this.shape.length);\n    for (let i = 0; i < locs.length - 1; ++i) {\n      locs[i] = Math.floor(index / this.strides[i]);\n      index -= locs[i] * this.strides[i];\n    }\n    locs[locs.length - 1] = index;\n    return locs;\n  }\n\n  fill(value: number) {\n    this.getValues().fill(value);\n  }\n\n  getData(): NDArrayData {\n    return this.data;\n  }\n\n  getValues(): Float32Array {\n    if (this.data.values == null) {\n      throwIfGPUNotInitialized();\n      this.data.values = GPGPU.downloadMatrixFromTexture(\n          this.data.texture!, this.data.textureShapeRC![0],\n          this.data.textureShapeRC![1]);\n      this.disposeTexture();\n    }\n    return this.data.values;\n  }\n\n  private uploadToGPU(preferredTexShape?: [number, number]) {\n    throwIfGPUNotInitialized();\n    this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(\n        GPGPU.gl, this.shape, preferredTexShape);\n    this.data.texture =\n        TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC);\n\n    GPGPU.uploadMatrixToTexture(\n        this.data.texture, this.data.textureShapeRC[0],\n        this.data.textureShapeRC[1], this.data.values!);\n\n    this.data.values = null!;\n  }\n\n  getTexture(preferredShapeRC?: [number, number]): WebGLTexture {\n    if (this.data.texture == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.texture!;\n  }\n\n  getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] {\n    if (this.data.textureShapeRC == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.textureShapeRC!;\n  }\n\n  dispose(): void {\n    this.data.values = null!;\n    this.shape = null!;\n    if (this.data.texture != null) {\n      this.disposeTexture();\n    }\n  }\n\n  private disposeTexture() {\n    throwIfGPUNotInitialized();\n    TEXTURE_MANAGER.releaseTexture(\n        this.data.texture!, this.data.textureShapeRC!);\n    this.data.texture = null!;\n    this.data.textureShapeRC = null!;\n  }\n\n  inGPU(): boolean {\n    return this.data.texture != null;\n  }\n\n  equals(t: NDArray): boolean {\n    return util.arraysEqual(this.shape, t.shape) &&\n        util.arraysEqual(this.getValues(), t.getValues());\n  }\n\n  static rand<T extends NDArray>(shape: number[], randFunction: () => number):\n      T {\n    const size = util.sizeFromShape(shape);\n    const values = new Float32Array(size);\n    for (let i = 0; i < size; i++) {\n      values[i] = randFunction();\n    }\n\n    return NDArray.make<T>(shape, {values});\n  }\n\n  static randNormal<T extends NDArray>(shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev));\n  }\n\n  static randTruncatedNormal<T extends NDArray>(\n      shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev, true));\n  }\n\n  static randUniform<T extends NDArray>(shape: number[], a: number, b: number) {\n    return NDArray.rand<T>(shape, () => util.randUniform(a, b));\n  }\n}\n\nexport class Scalar extends NDArray {\n  constructor(data: NDArrayData) {\n    if (data.texture != null) {\n      data.textureShapeRC = [1, 1];\n    }\n    super([], data);\n  }\n\n  static new(value: number) {\n    return new Scalar({values: new Float32Array([value])});\n  }\n\n  static ZERO = Scalar.new(0);\n  static ONE = Scalar.new(1);\n  static TWO = Scalar.new(2);\n  static NEG_ONE = Scalar.new(-1);\n\n  get(): number {\n    return this.getValues()[0];\n  }\n\n  set(value: number) {\n    this.getValues()[0] = value;\n  }\n\n  add(value: number) {\n    this.getValues()[0] += value;\n  }\n}\n\nexport class Array1D extends NDArray {\n  shape: [number];\n\n  constructor(data: NDArrayData) {\n    const shape = (data.values != null) ?\n        [data.values.length] :\n        [util.sizeFromShape(data.textureShapeRC!)];\n    super(shape, data);\n  }\n\n  static new(values: Float32Array|number[]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      util.assert(\n          inferredShape.length === 1,\n          `Error constructing Array1D. Shape of values ${inferredShape} is ` +\n              `not 1 dimensional.`);\n    }\n    return new Array1D({values: toTypedArray(values)});\n  }\n\n  get(i: number): number {\n    return this.getValues()[i];\n  }\n\n  set(value: number, i: number) {\n    this.getValues()[i] = value;\n  }\n\n  add(value: number, i: number) {\n    this.getValues()[i] += value;\n  }\n\n  locToIndex(loc: [number]): number {\n    return loc[0];\n  }\n\n  indexToLoc(index: number): [number] {\n    return [index];\n  }\n\n  static zeros(shape: [number]): Array1D {\n    return NDArray.zeros<Array1D>(shape);\n  }\n}\n\nexport class Array2D extends NDArray {\n  shape: [number, number];\n\n  private stride0: number;\n\n  constructor(shape: [number, number], data: NDArrayData) {\n    util.assert(shape.length === 2, 'Shape should be of length 2');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n  }\n\n  static new(\n      shape: [number, number], values: Float32Array|number[]|number[][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array2D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array2D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number) {\n    return this.getValues()[this.stride0 * i + j];\n  }\n\n  set(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] = value;\n  }\n\n  add(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] += value;\n  }\n\n  locToIndex(locs: [number, number]): number {\n    return this.stride0 * locs[0] + locs[1];\n  }\n\n  indexToLoc(index: number): [number, number] {\n    return [Math.floor(index / this.stride0), index % this.stride0];\n  }\n\n  static zeros(shape: [number, number]): Array2D {\n    return NDArray.zeros<Array2D>(shape);\n  }\n}\n\nexport class Array3D extends NDArray {\n  shape: [number, number, number];\n  private stride0: number;\n  private stride1: number;\n\n  constructor(shape: [number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 3, 'Shape should be of length 3');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n  }\n\n  static new(\n      shape: [number, number, number],\n      values: Float32Array|number[]|number[][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array3D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array3D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number) {\n    return this.getValues()[this.stride0 * i + this.stride1 * j + k];\n  }\n\n  set(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] += value;\n  }\n\n  locToIndex(locs: [number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2];\n  }\n\n  indexToLoc(index: number): [number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    return [i, Math.floor(index / this.stride1), index % this.stride1];\n  }\n\n  static zeros(shape: [number, number, number]): Array3D {\n    return NDArray.zeros<Array3D>(shape);\n  }\n}\n\nexport class Array4D extends NDArray {\n  shape: [number, number, number, number];\n  private stride0: number;\n  private stride1: number;\n  private stride2: number;\n\n  constructor(shape: [number, number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 4, 'Shape should be of length 4');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n    this.stride2 = this.strides[2];\n  }\n\n  static new(\n      shape: [number, number, number, number],\n      values: Float32Array|number[]|number[][][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array4D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array4D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number, l: number) {\n    return this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l];\n  }\n\n  set(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value;\n  }\n\n  locToIndex(locs: [number, number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] +\n        this.stride2 * locs[2] + locs[3];\n  }\n\n  indexToLoc(index: number): [number, number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    const j = Math.floor(index / this.stride1);\n    index -= j * this.stride1;\n    return [i, j, Math.floor(index / this.stride2), index % this.stride2];\n  }\n\n  static zeros(shape: [number, number, number, number]): Array4D {\n    return NDArray.zeros<Array4D>(shape);\n  }\n}\n\ntype ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][];\n\nfunction toTypedArray(a: ArrayData): Float32Array {\n  return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a));\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    uniform sampler2D matrixAScalar;\n    uniform sampler2D matrixBScalar;\n    varying vec2 resultUV;\n\n    const vec2 halfTexel = vec2(0.5, 0.5);\n\n    void main() {\n      float a = texture2D(matrixA, resultUV).r;\n      float b = texture2D(matrixB, resultUV).r;\n      float aScalar = texture2D(matrixAScalar, halfTexel).r;\n      float bScalar = texture2D(matrixBScalar, halfTexel).r;\n      vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n      gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n    }`;\n}\n\nexport function addScaledMatrices(\n    gpgpu: GPGPUContext, addScaledMatricesProgram: WebGLProgram,\n    a: WebGLTexture, b: WebGLTexture, rows: number, columns: number,\n    aScalar: WebGLTexture, bScalar: WebGLTexture, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(addScaledMatricesProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2);\n  gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3);\n  gpgpu.executeProgram();\n}\n\nexport function uploadAddScaledMatricesDownload(\n    a: Float32Array, b: Float32Array, rows: number, columns: number,\n    aScalar: number, bScalar: number): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource());\n\n  const aTex = gpgpu.createMatrixTexture(rows, columns);\n  const bTex = gpgpu.createMatrixTexture(rows, columns);\n  const aScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const bScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const resultTex = gpgpu.createMatrixTexture(rows, columns);\n\n  gpgpu.uploadMatrixToTexture(aTex, rows, columns, a);\n  gpgpu.uploadMatrixToTexture(bTex, rows, columns, b);\n  gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar]));\n  gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar]));\n\n  addScaledMatrices(\n      gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex,\n      resultTex);\n\n  const result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns);\n\n  gpgpu.deleteMatrixTexture(aTex);\n  gpgpu.deleteMatrixTexture(bTex);\n  gpgpu.deleteMatrixTexture(resultTex);\n  gpgpu.deleteMatrixTexture(aScalarTex);\n  gpgpu.deleteMatrixTexture(bScalarTex);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\n\nimport * as binaryop_gpu from './binaryop_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport type Operation = '+' | '-' | '*' | '/';\n\nexport enum OperandType {\n  MATRIX,\n  SCALAR\n}\n\nexport function getFragmentShaderSource(\n    aType: OperandType, aOrientation: MatrixOrientation, op: Operation,\n    bType: OperandType, bOrientation: MatrixOrientation): string {\n  const aUV = operandToShaderSnippet(aType, aOrientation);\n  const bUV = operandToShaderSnippet(bType, bOrientation);\n  const resultOp = `gl_FragColor = vec4(a ${op} b, 0, 0, 0);`;\n  return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp);\n}\n\nfunction operandToShaderSnippet(\n    operand: OperandType, orientation: MatrixOrientation): string {\n  switch (operand) {\n    case OperandType.MATRIX:\n      return 'resultUV' +\n          (orientation === MatrixOrientation.REGULAR ? '.st' : '.ts');\n    case OperandType.SCALAR:\n      return 'vec2(0.5, 0.5)';\n    default:\n      throw new Error('Unknown operand type');\n  }\n}\n\nexport function addSubMulDiv(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  return binaryop_gpu.binaryOp(\n      gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result,\n      resultShapeRowCol);\n}\n\nexport function uploadScalarPlusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '+', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixMinusScalarDownload(\n    a: Float32Array, aShape: [number, number], b: number,\n    aOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR,\n      MatrixOrientation.REGULAR);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      a, aShape, new Float32Array([b]), [1, 1], src);\n}\n\nexport function uploadScalarMinusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '-', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadScalarTimesMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '*', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixTimesMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n\nexport function uploadMatrixPlusMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as argminmax_gpu from './argminmax_gpu';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      float argMaxA = getArgMinMax(matrixA);\n      float argMaxB = getArgMinMax(matrixB);\n      float value;\n      if (isNaN(argMaxA)) {\n        value = argMaxA;\n      } else if (isNaN(argMaxB)) {\n        value = argMaxB;\n      } else {\n        value = float(argMaxA == argMaxB);\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getArgMaxEqualsFragmentShaderSource(\n    rows: number, columns: number): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function argMaxEquals(\n    gpgpu: GPGPUContext, maxEqualsProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, numRows: number, numCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(maxEqualsProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n    }`;\n}\n\nfunction getArgMinMaxFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    getFragmentShaderGetArgMinMaxSource(compOp, rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function getArgMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '<');\n}\n\nexport function getArgMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '>');\n}\n\nexport function getFragmentShaderGetArgMinMaxSource(\n    compOp: string, rows: number, columns: number) {\n  return `\n    const vec2 dimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    float getArgMinMax(in sampler2D matrix) {\n      vec2 bestCR = vec2(0, 0);\n      float bestValue = texture2D(matrix, bestCR).r;\n\n      for (float c = 0.0; c < dimCR.x; c += 1.0) {\n        for (float r = 0.0; r < dimCR.y; r += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / dimCR;\n          float value = texture2D(matrix, uv).r;\n          if (isNaN(value)) {\n            return value;\n          }\n          if (value ${compOp} bestValue) {\n            bestValue = value;\n            bestCR = cr;\n          }\n        }\n      }\n      return bestCR.x + (bestCR.y * dimCR.x);\n    }\n  `;\n}\n\nexport function argMinMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderAvgPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'avg', false);\n}\n\nexport function avgPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    xTexShapeRC: [number, number], meanTexShapeRC: [number, number],\n    varianceTexShapeRC: [number, number],\n    offsetTexShapeRC: [number, number]|null,\n    scaleTexShapeRC?: [number, number]|null, varianceEpsilon = 0.001): string {\n  let offsetSamplerSnippet = '';\n  let offsetShapeInitializationSnippet = '';\n  let offsetCoordsSnippet = '';\n  let offsetUVSnippet = '';\n  let offsetValueSnippet = '';\n  let offsetOperationSnippet = '0.0';\n\n  let scaleSamplerSnippet = '';\n  let scaleShapeInitializationSnippet = '';\n  let scaleCoordsSnippet = '';\n  let scaleUVSnippet = '';\n  let scaleValueSnippet = '';\n  let scaleOperationSnippet = '';\n\n  if (offsetTexShapeRC != null) {\n    offsetSamplerSnippet = 'uniform sampler2D offset;';\n    offsetShapeInitializationSnippet = `const vec2 offsetShapeCR = vec2(\n            ${offsetTexShapeRC[1]}, ${offsetTexShapeRC[0]});`;\n    offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);';\n    offsetUVSnippet =\n        'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;';\n    offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;';\n    offsetOperationSnippet = 'offsetValue';\n  }\n\n  if (scaleTexShapeRC != null) {\n    scaleSamplerSnippet = 'uniform sampler2D scale;';\n    scaleShapeInitializationSnippet = `const vec2 scaleShapeCR = vec2(\n            ${scaleTexShapeRC[1]}, ${scaleTexShapeRC[0]});`;\n    scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);';\n    scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;';\n    scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;';\n    scaleOperationSnippet = 'inv *= scaleValue;';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D mean;\n    uniform sampler2D variance;\n    ${offsetSamplerSnippet}\n    ${scaleSamplerSnippet}\n\n    varying vec2 resultUV;\n\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 meanShapeCR = vec2(${meanTexShapeRC[1]}, ${meanTexShapeRC[0]});\n    const vec2 varianceShapeCR = vec2(\n        ${varianceTexShapeRC[1]}, ${varianceTexShapeRC[0]});\n\n    ${offsetShapeInitializationSnippet}\n    ${scaleShapeInitializationSnippet}\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const float varianceEpsilon = ${varianceEpsilon};\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n      vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n      ${offsetCoordsSnippet}\n      ${scaleCoordsSnippet}\n\n      vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n      vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n      ${offsetUVSnippet}\n      ${scaleUVSnippet}\n\n      float xValue = texture2D(x, resultUV).r;\n      float meanValue = texture2D(mean, meanUV).r;\n      float varianceValue = texture2D(variance, varianceUV).r;\n      ${offsetValueSnippet}\n      ${scaleValueSnippet}\n\n      float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n      ${scaleOperationSnippet}\n      float xTimesInv = xValue * inv;\n      float meanTimesInvWithOffset = ${offsetOperationSnippet}\n          - meanValue * inv;\n\n      gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n    }`;\n}\n\nexport function batchNormalization(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    xShapeRowCol: [number, number], mean: WebGLTexture,\n    meanShapeRowCol: [number, number], variance: WebGLTexture,\n    varianceShapeRowCol: [number, number], offset: WebGLTexture|null,\n    offsetShapeRowCol: [number, number]|null, scale: WebGLTexture|null,\n    scaleShapeRowCol: [number, number]|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.setInputMatrixTexture(mean, 'mean', 1);\n  gpgpu.setInputMatrixTexture(variance, 'variance', 2);\n  let nextIndex = 3;\n  if (offset != null) {\n    gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex);\n    nextIndex++;\n  }\n  if (scale != null) {\n    gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    aResultUV: string, bResultUV: string, op: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;\n\n    void main() {\n      float a = texture2D(matrixA, ${aResultUV}).r;\n      float b = texture2D(matrixB, ${bResultUV}).r;\n      ${op}\n    }`;\n}\n\nexport function binaryOp(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n\nexport function uploadBinaryOpDownload(\n    a: Float32Array, aShape: [number, number], b: Float32Array,\n    bShape: [number, number], fragmentShaderSource: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(fragmentShaderSource);\n\n  const aTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(aShape[0], aShape[1]);\n  const bTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(bShape[0], bShape[1]);\n\n  const resultShape: [number, number] =\n      [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])];\n\n  const resultTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(resultShape[0], resultShape[1]);\n\n  gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a);\n  gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b);\n\n  binaryOp(\n      gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture,\n      resultShape);\n  const result = gpgpu.downloadMatrixFromTexture(\n      resultTexture, resultShape[0], resultShape[1]);\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    x1ShapeRCD: [number, number, number], x2ShapeRCD: [number, number, number],\n    resultShapeRCD: [number, number, number], axis: number): string {\n  const x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD);\n  const x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD);\n\n  const yAxes = ['yR', 'yC', 'yD'];\n  const concatAxis = yAxes[axis];\n\n  return `\n    precision highp float;\n    uniform sampler2D x1;\n    uniform sampler2D x2;\n\n    const vec2 x1ShapeCR = vec2(${x1TexShapeRC[1]}, ${x1TexShapeRC[0]});\n    const vec2 x2ShapeCR = vec2(${x2TexShapeRC[1]}.0, ${x2TexShapeRC[0]}.0);\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${resultShapeRCD[2]}.0);\n      float yD = mod(yTexCR.x, ${resultShapeRCD[2]}.0);\n\n      float value = 0.0;\n\n      if (${concatAxis} < ${x1ShapeRCD[axis]}.0) {\n        // Map yR, yC, yD back to x1 coordinates.\n        vec2 x1CR = vec2(yC * ${x1ShapeRCD[2]}.0 + yD, yR);\n        vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n        value = texture2D(x1, x1UV).r;\n      } else {\n        ${concatAxis} = ${concatAxis} - ${x1ShapeRCD[axis]}.0;\n\n        // Map yR, yC, yD back to x2 coordinates.\n        vec2 x2CR = vec2(yC * ${x2ShapeRCD[2]}.0 + yD, yR);\n        vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n        value = texture2D(x2, x2UV).r;\n      }\n\n      gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function concat3D(\n    gpgpu: GPGPUContext, program: WebGLProgram, x1: WebGLTexture,\n    x2: WebGLTexture, result: WebGLTexture, resultShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x1, 'x1', 0);\n  gpgpu.setInputMatrixTexture(x2, 'x2', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport * as conv_gpu from './conv_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderDerWeightsSource(\n    xShapeRowColDepth: [number, number, number], fSize: number,\n    outputDepth: number, stride: number, zeroPad: number) {\n  const getMatrixValueOrZeroPad =\n      conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const inputDepth = xShapeRowColDepth[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth);\n\n  const yShape = conv_util.computeOutputShape3D(\n      xShapeRowColDepth, fSize, outputDepth, stride, zeroPad);\n  const yNumRows = yShape[0];\n  const yNumCols = yShape[1];\n  const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape);\n\n  const fSizeTimesInputDepth = fSize * inputDepth;\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D dy;\n  `;\n\n  return prologue + '\\n' + getMatrixValueOrZeroPad + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]});\n\n    void main() {\n      vec2 wTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n      float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0);\n      float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0;\n      float wC = floor(wTexRLeftover / ${inputDepth}.0);\n      float d1 = mod(wTexRLeftover, ${inputDepth}.0);\n      float d2 = wTexCR.x;\n\n      // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float xR = wR + yR * ${stride}.0 - ${zeroPad}.0;\n        float xTexR = xR;\n        float yTexR = yR;\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          float xC = wC + yC * ${stride}.0 - ${zeroPad}.0;\n\n          // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) +\n                        vec2(d1, d2);\n          float xTexC = xyTexC.x;\n          float yTexC = xyTexC.y;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read x(xR, xC, d1) (potentially zero-padded).\n          float xValue =\n            getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n          dotProd += (xValue * dyValue);\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderConvTransposeSource(\n    xShapeRCD: [number, number, number], fSize: number, origInputDepth: number,\n    origStride: number, origPad: number, hasBias: boolean) {\n  const pad = fSize - 1 - origPad;\n  const [xRows, xCols, origOutputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize);\n\n  const getBiasValue = hasBias ?\n      conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) :\n      '';\n  const biasPrologue = hasBias ? 'uniform sampler2D biases;' : '';\n  const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : '';\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    ${biasPrologue}\n    `;\n\n  return prologue + '\\n' + getBiasValue + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${origInputDepth}.0);\n      float d2 = mod(yTexCR.x, ${origInputDepth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float xR = (xRCorner + wR) / ${origStride}.0;\n        // TODO(smilkov): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) {\n          continue;\n        }\n\n        float wRPerm = ${fSize}.0 - 1.0 - wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float xC = (xCCorner + wC) / ${origStride}.0;\n          if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) {\n            continue;\n          }\n\n          float wCPerm = ${fSize}.0 - 1.0 - wC;\n          float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 +\n                        wCPerm * ${origInputDepth}.0 + d2;\n\n          for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${origOutputDepth}.0 + d1;\n            float wTexC = d1;\n\n            // Read x(xR, xC, d1).\n            vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n            float xValue = texture2D(x, xUV).r;\n\n            // Read w(wRPerm, wCPerm, d2, d1).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      ${biasOperation}\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderDerBiasSource(\n    dyShapeRCD: [number, number, number]) {\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const [yNumRows, yNumCols, outputDepth] = dyShapeRCD;\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n      // The bias texture RC shape is [1, d2].\n      float d2 = biasTexCR.x;\n\n      float derBias = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float yTexR = yR;\n\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          float yTexC = yC * ${outputDepth}.0 + d2;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          derBias += dyValue;\n        }\n      }\n      gl_FragColor = vec4(derBias, 0, 0, 0);\n    }`;\n}\n\nexport function derBias(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    result: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.executeProgram();\n}\n\nexport function derWeights(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    dyTex: WebGLTexture, result: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 1);\n  gpgpu.executeProgram();\n}\n\nexport function convTranspose(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    weightsTex: WebGLTexture, biasesTex: WebGLTexture|null,\n    resultTex: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1);\n  if (biasesTex != null) {\n    gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    uniform sampler2D biases;\n    varying vec2 resultUV;`;\n}\n\nexport function getFragmentShaderGetMatrixValueOrZeroPadSource(): string {\n  return `\n    float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n        vec2 requestedCR) {\n      vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n      float value = texture2D(matrix, uv).r;\n      bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n      bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n      bool outside = lessThanZero || greaterThanOne;\n      return mix(value, 0.0, float(outside));\n    }`;\n}\n\nexport function getFragmentShaderConvolveSource(\n    xShapeRCD: [number, number, number], fSize: number, outputDepth: number,\n    stride: number, pad: number, hasBias: boolean) {\n  const [xRows, xCols, inputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n\n  return `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${outputDepth}.0);\n      float d2 = mod(yTexCR.x, ${outputDepth}.0);\n      float wTexC = d2;\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n\n          for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${inputDepth}.0 + d1;\n            float wTexR = wR * ${fSize * inputDepth}.0 +\n                wC * ${inputDepth}.0 + d1;\n\n            float xValue =\n                getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n            // Read w(wR, wC, d1, d2).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      if (${hasBias}) {\n        dotProd += getBiasValue(biases, d2);\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderGetBiasValueSource(outputDepth: number):\n    string {\n  return `\n    float getBiasValue(in sampler2D bias, float biasC) {\n      const vec2 biasShapeCR = vec2(${outputDepth}, 1);\n      vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0);\n      vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n      return texture2D(bias, biasUV).r;\n    }`;\n}\n\nexport function getFragmentShaderSource(\n    aShapeRowColDepth: [number, number, number], resultDepth: number,\n    fieldSize: number, stride: number, zeroPad: number,\n    hasBias: boolean): string {\n  const aShapeRC: [number, number] =\n      conv_util.computeTexShapeFrom3D(aShapeRowColDepth);\n\n  const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape(\n      aShapeRowColDepth[2], resultDepth, fieldSize);\n\n  const prologue = getFragmentShaderPrologueSource();\n  const getMatrixValueOrZeroPad =\n      getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const convolve = getFragmentShaderConvolveSource(\n      aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias);\n  const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth);\n\n  return [\n    prologue,\n    getMatrixValueOrZeroPad,\n    getBiasValue,\n    convolve,\n  ].join('\\n');\n}\n\nexport function convolve(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'x', 0);\n  gpgpu.setInputMatrixTexture(weights, 'weights', 1);\n  if (biases != null) {\n    gpgpu.setInputMatrixTexture(biases, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  return `\n    precision highp float;\n    uniform sampler2D source;\n    uniform vec2 sourceStartCR;\n    uniform vec2 destStartCR;\n\n    const vec2 sourceShapeCR =\n      vec2(${sourceShapeRowCol[1]}, ${sourceShapeRowCol[0]});\n    const vec2 sourceSizeCR =\n      vec2(${sourceSizeRowCol[1]}, ${sourceSizeRowCol[0]});\n    const vec2 destSizeCR =\n      vec2(${destSizeRowCol[1]}, ${destSizeRowCol[0]});\n\n    void main() {\n      vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n      float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n      vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n        floor(destOffsetFlat / sourceSizeCR.x));\n      vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n      vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n      gl_FragColor = texture2D(source, sourceUV);\n    }`;\n}\n\nexport function copy(\n    gpgpu: GPGPUContext, program: WebGLProgram, source: WebGLTexture,\n    sourceShapeRowCol: [number, number], sourceStartRowCol: [number, number],\n    sourceSizeRowCol: [number, number], dest: WebGLTexture,\n    destShapeRowCol: [number, number], destStartRowCol: [number, number],\n    destSizeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]);\n  gpgpu.setOutputMatrixWriteRegion(\n      destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1],\n      destSizeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(source, 'source', 0);\n  const sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR');\n  gpgpu.gl.uniform2f(\n      sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]);\n  const destStartCRLoc = gpgpu.getUniformLocation('destStartCR');\n  gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getExpUnaryOp(): string {\n  return 'gl_FragColor = vec4(exp(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp());\n}\n\nexport function exp(\n    gpgpu: GPGPUContext, expProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result);\n}\n\nexport function uploadExpDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from './gpgpu_util';\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nimport {WebGLLoseContextExtension} from './webgl_util';\n\nexport class GPGPUContext {\n  gl: WebGLRenderingContext;\n  textureFloatExtension: {};\n  colorBufferFloatExtension: {};\n  loseContextExtension: WebGLLoseContextExtension;\n  vertexBuffer: WebGLBuffer;\n  indexBuffer: WebGLBuffer;\n  framebuffer: WebGLFramebuffer;\n  outputTexture: WebGLTexture|null = null;\n  program: WebGLProgram|null = null;\n  private disposed = false;\n  private autoDebugValidate = false;\n\n  constructor(gl?: WebGLRenderingContext) {\n    if (gl != null) {\n      this.gl = gl;\n    } else {\n      this.gl = gpgpu_util.createWebGLContext();\n    }\n\n    // WebGL 2.0 enables texture floats without an extension.\n    if (!webgl_util.isWebGL2Enabled()) {\n      this.textureFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float');\n    } else {\n      this.colorBufferFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float');\n    }\n\n    this.loseContextExtension =\n        webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as\n        WebGLLoseContextExtension;\n    this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl);\n    this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl);\n    this.framebuffer = webgl_util.createFramebuffer(this.gl);\n  }\n\n  public dispose() {\n    this.throwIfDisposed();\n    if (this.program != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound WebGLProgram.' +\n          ' This is probably a resource leak, delete the program with ' +\n          'GPGPUContext.deleteProgram before disposing.');\n    }\n    if (this.outputTexture != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound output matrix ' +\n          'texture.  This is probably a resource leak, delete the output ' +\n          'matrix texture with GPGPUContext.deleteMatrixTexture before ' +\n          'disposing.');\n    }\n    const gl = this.gl;\n    webgl_util.callAndCheck(gl, () => gl.finish());\n    webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer));\n    webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer));\n    webgl_util.callAndCheck(\n        gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer));\n    this.loseContextExtension.loseContext();\n    this.disposed = true;\n  }\n\n  public enableAutomaticDebugValidation(enabled: boolean) {\n    this.autoDebugValidate = enabled;\n    webgl_util.enableDebugWebGLErrorChecking(enabled);\n  }\n\n  public createMatrixTexture(rows: number, columns: number): WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createMatrixTexture(this.gl, rows, columns);\n  }\n\n  public uploadPixelDataToTexture(\n      texture: WebGLTexture,\n      pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n    this.throwIfDisposed();\n    gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels);\n  }\n\n  public createPackedMatrixTexture(rows: number, columns: number):\n      WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns);\n  }\n\n  public deleteMatrixTexture(texture: WebGLTexture) {\n    this.throwIfDisposed();\n    if (this.outputTexture === texture) {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n      this.outputTexture = null;\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture));\n  }\n\n  public uploadMatrixToTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    const numChannels = 1;\n    return gpgpu_util.uploadMatrixToTexture(\n        this.gl, texture, rows, columns, matrix, numChannels);\n  }\n\n  public uploadMatrixToPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    return gpgpu_util.uploadMatrixToPackedTexture(\n        this.gl, texture, rows, columns, matrix);\n  }\n\n  public downloadMatrixFromTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () =>\n            gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns));\n  }\n\n  public downloadMatrixFromPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () => gpgpu_util.downloadMatrixFromPackedOutputTexture(\n            this.gl, rows, columns));\n  }\n\n  public createProgram(fragmentShaderSource: string): WebGLProgram {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    const fragmentShader: WebGLShader =\n        webgl_util.createFragmentShader(gl, fragmentShaderSource);\n    const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl);\n    const program: WebGLProgram = webgl_util.createProgram(gl);\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader));\n    webgl_util.linkProgram(gl, program);\n    if (this.autoDebugValidate) {\n      webgl_util.validateProgram(gl, program);\n    }\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader));\n    return program;\n  }\n\n  public deleteProgram(program: WebGLProgram) {\n    this.throwIfDisposed();\n    if (program === this.program) {\n      this.program = null;\n    }\n    if (program != null) {\n      webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program));\n    }\n  }\n\n  public setProgram(program: WebGLProgram|null) {\n    this.throwIfDisposed();\n    this.program = program;\n    if ((this.program != null) && this.autoDebugValidate) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program));\n  }\n\n  public getUniformLocation(uniformName: string): WebGLUniformLocation {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    return webgl_util.getProgramUniformLocationOrThrow(\n        this.gl, this.program!, uniformName);\n  }\n\n  public setInputMatrixTexture(\n      inputMatrixTexture: WebGLTexture, uniformName: string,\n      textureUnit: number) {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    webgl_util.bindTextureToProgramUniformSampler(\n        this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit);\n  }\n\n  public setOutputMatrixTexture(\n      outputMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows);\n  }\n\n  public setOutputPackedMatrixTexture(\n      outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.throwIfDisposed();\n    const [width, height] =\n        tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n    this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height);\n  }\n\n  public setOutputMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    this.setOutputMatrixWriteRegionDriver(\n        startColumn, startRow, numColumns, numRows);\n  }\n\n  public setOutputPackedMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    throw new Error('setOutputPackedMatrixWriteRegion not implemented.');\n  }\n\n  public debugValidate() {\n    if (this.program != null) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.validateFramebuffer(this.gl);\n  }\n\n  public executeProgram() {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    const gl = this.gl;\n    gpgpu_util.bindVertexProgramAttributeStreams(\n        gl, this.program!, this.vertexBuffer);\n    if (this.autoDebugValidate) {\n      this.debugValidate();\n    }\n    webgl_util.callAndCheck(\n        gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0));\n  }\n\n  public blockUntilAllProgramsCompleted() {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(this.gl, () => this.gl.finish());\n  }\n\n  private downloadMatrixDriver(\n      texture: WebGLTexture,\n      downloadAndDecode: () => Float32Array): Float32Array {\n    this.throwIfDisposed();\n    webgl_util.bindColorTextureToFramebuffer(\n        this.gl, texture, this.framebuffer);\n    const result = downloadAndDecode();\n    if (this.outputTexture != null) {\n      webgl_util.bindColorTextureToFramebuffer(\n          this.gl, this.outputTexture, this.framebuffer);\n      if (this.autoDebugValidate) {\n        webgl_util.validateFramebuffer(this.gl);\n      }\n    } else {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n    }\n    return result;\n  }\n\n  private setOutputMatrixTextureDriver(\n      outputMatrixTextureMaybePacked: WebGLTexture, width: number,\n      height: number) {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    webgl_util.bindColorTextureToFramebuffer(\n        gl, outputMatrixTextureMaybePacked, this.framebuffer);\n    if (this.autoDebugValidate) {\n      webgl_util.validateFramebuffer(gl);\n    }\n    this.outputTexture = outputMatrixTextureMaybePacked;\n    webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height));\n    webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height));\n  }\n\n  private setOutputMatrixWriteRegionDriver(\n      x: number, y: number, width: number, height: number) {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(\n        this.gl, () => this.gl.scissor(x, y, width, height));\n  }\n\n  private throwIfDisposed() {\n    if (this.disposed) {\n      throw new Error('Attempted to use disposed GPGPUContext.');\n    }\n  }\n\n  private throwIfNoProgram() {\n    if (this.program == null) {\n      throw new Error('No GPU program is currently set.');\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nexport function getWebGLContextAttributes(): WebGLContextAttributes {\n  return {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: true\n  };\n}\n\nexport function createWebGLContext(canvas?: HTMLCanvasElement) {\n  const attributes = getWebGLContextAttributes();\n  let gl: WebGLRenderingContext;\n  if (canvas != null) {\n    gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes);\n  } else {\n    gl = webgl_util.createWebGLRenderingContext(attributes);\n  }\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE));\n  webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK));\n  return gl;\n}\n\nexport function createVertexShader(gl: WebGLRenderingContext): WebGLShader {\n  const vertexShaderSource = `\n    precision highp float;\n    attribute vec3 clipSpacePos;\n    attribute vec2 uv;\n    varying vec2 resultUV;\n\n    void main() {\n      gl_Position = vec4(clipSpacePos, 1);\n      resultUV = uv;\n    }`;\n  return webgl_util.createVertexShader(gl, vertexShaderSource);\n}\n\nexport function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // [x y z u v] * [upper-left, lower-left, upper-right, lower-right]\n  const vertexArray = new Float32Array(\n      [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]);\n  return webgl_util.createStaticVertexBuffer(gl, vertexArray);\n}\n\nexport function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // OpenGL (and WebGL) have \"CCW == front\" winding\n  const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]);\n  return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices);\n}\n\nfunction getTextureInternalFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled()) {\n    if (numChannels === 4) {\n      // tslint:disable-next-line:no-any\n      return (gl as any).RGBA32F;\n    }\n    // tslint:disable-next-line:no-any\n    return (gl as any).R32F;\n  }\n  return gl.RGBA;\n}\n\nfunction getTextureFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled() && numChannels === 1) {\n    // tslint:disable-next-line:no-any\n    return (gl as any).RED;\n  }\n  return gl.RGBA;\n}\n\nfunction createAndConfigureTexture(\n    gl: WebGLRenderingContext, width: number, height: number,\n    numChannels: number): WebGLTexture {\n  webgl_util.validateTextureSize(gl, width, height);\n  const texture = webgl_util.createTexture(gl);\n\n  const tex2d = gl.TEXTURE_2D;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  const format = getTextureFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n  return texture;\n}\n\nexport function createMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 1;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createColorMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createPackedMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function bindVertexProgramAttributeStreams(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    vertexBuffer: WebGLBuffer) {\n  const posOffset = 0;               // x is the first buffer element\n  const uvOffset = 3 * 4;            // uv comes after [x y z]\n  const stride = (3 * 4) + (2 * 4);  // xyz + uv, each entry is 4-byte float.\n  webgl_util.callAndCheck(\n      gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer));\n  webgl_util.bindVertexBufferToProgramAttribute(\n      gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset);\n  try {\n    webgl_util.bindVertexBufferToProgramAttribute(\n        gl, program, 'uv', vertexBuffer, 2, stride, uvOffset);\n  } catch (e) {\n    // Programs with 1x1 output textures don't use the uv attribute.\n    // This can cause the shader linker to dead-strip it, so we shouldn't\n    // complain or fail if it's not present.\n    if (!e.hasOwnProperty('namedVertexAttributeNotFound')) {\n      throw e;\n    }\n  }\n}\n\nexport function uploadPixelDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n  const numChannels = 4;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nfunction uploadDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, width: number,\n    height: number, data: Float32Array, numChannels: number) {\n  const textureFormat = getTextureFormat(gl, numChannels);\n\n  webgl_util.validateTextureSize(gl, width, height);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texSubImage2D(\n          gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT,\n          data));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function uploadMatrixToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array, numChannels: number) {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture =\n      numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n\n  uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels);\n}\n\nexport function uploadMatrixToPackedTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array) {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA);\n  const numChannels = 4;\n  uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels);\n}\n\nexport function downloadMatrixFromOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture = 4;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          rows * columns, channelsPerTexture));\n  const textureFormat = getTextureFormat(gl, channelsPerTexture);\n\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray));\n\n  const matrix = new Float32Array(rows * columns);\n  tex_util.decodeMatrixFromUnpackedArray(\n      unpackedArray, matrix, channelsPerTexture);\n  return matrix;\n}\n\nexport function downloadMatrixFromPackedOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA));\n  const matrix = new Float32Array(rows * columns);\n  return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getLogUnaryOp(): string {\n  return 'gl_FragColor = vec4(log(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp());\n}\n\nexport function log(\n    gpgpu: GPGPUContext, logProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result);\n}\n\nexport function uploadLogDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          aMax = max(aMax, aCur);\n        }\n      }\n\n      float expSum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          expSum += exp(aCur - aMax);\n        }\n      }\n\n      gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n    }`;\n}\n\nexport function logSumExp(\n    gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(logSumExpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadLogSumExpDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result[0];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderMaxPoolBackprop(\n    dyShapeRCD: [number, number, number], fSize: number, origStride: number,\n    origPad: number) {\n  const origInputDepth = dyShapeRCD[2];\n  const pad = fSize - 1 - origPad;\n  const [dyRows, dyCols, depth] = dyShapeRCD;\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n    uniform sampler2D maxPos;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n      float dxR = dxTexCR.y;\n      float dxC = floor(dxTexCR.x / ${origInputDepth}.0);\n      float d = mod(dxTexCR.x, ${origInputDepth}.0);\n\n      vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0);\n      float dyRCorner = dyRCCorner.x;\n      float dyCCorner = dyRCCorner.y;\n\n      // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float dyR = (dyRCorner + wR) / ${origStride}.0;\n        // TODO(nsthorat): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) {\n          continue;\n        }\n\n        float dyTexR = dyR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float dyC = (dyCCorner + wC) / ${origStride}.0;\n          if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) {\n            continue;\n          }\n\n          float dyTexC = dyC * ${depth}.0 + d;\n\n          // Read dy(dyR, dyC, d).\n          vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read maxPos(dyR, dyC, d).\n          float maxPosValue =\n              ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r;\n\n          // Get the current value, check it against the value from the\n          // position matrix.\n          float curPosValue = wR * ${fSize}.0 + wC;\n          float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n          dotProd += dyValue * mask;\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function maxPoolBackprop(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    maxPositionsTex: WebGLTexture, resultTex: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMaxPoolPositionsSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, true);\n}\n\nexport function getFragmentShaderMaxPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, false);\n}\n\nfunction getFragmentShaderMaxPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, computeMaxPositions: boolean) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions);\n}\n\nexport function maxPoolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMinPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'min', false);\n}\n\nexport function minPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 outputColumnRow;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      float value = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / aDimCR;\n          float candidate = texture2D(matrixA, uv).r;\n          if (isNaN(candidate)) {\n            gl_FragColor = vec4(candidate, 0, 0, 0);\n            return;\n          }\n          value = ${compOp}(value, candidate);\n        }\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'min');\n}\n\nexport function getMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'max');\n}\n\nexport function minMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\nimport {Array2D} from '../ndarray';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as shader_compiler from './shader_compiler';\n\nexport function getFragmentShader(\n    a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  const sharedDim =\n      (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]);\n  const aSnippet =\n      (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow';\n  const bSnippet =\n      (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i';\n\n  const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}];\n  const userCode = `\n    const float sharedDim = ${sharedDim}.0;\n\n    float dotARowBCol(float aRow, float bCol) {\n      float result = 0.0;\n      for (float i = 0.0; i < sharedDim; i += 1.0) {\n        float a = getMatrixA(${aSnippet});\n        float b = getMatrixB(${bSnippet});\n        result += (a * b);\n      }\n      return result;\n    }\n\n    void main() {\n      vec2 resRC = getOutputCoords();\n      setOutput(dotARowBCol(resRC.x, resRC.y));\n    }\n  `;\n  return shader_compiler.makeShader(inputs, out, userCode);\n}\n\nexport function multiplyMatrix(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getNegUnaryOp(): string {\n  return 'gl_FragColor = vec4(-value, 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp());\n}\n\nexport function neg(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, rows: number,\n    columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result);\n}\n\nexport function uploadNegDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) {\n  if (poolType === 'avg' && computePositions) {\n    throw new Error('Cannot compute positions for average pool.');\n  }\n\n  const depth = xShapeRCD[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n\n  let returnValue = 'minMaxValue';\n  if (computePositions) {\n    returnValue = 'minMaxPosition';\n  } else if (poolType === 'avg') {\n    returnValue = 'avgValue';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    varying vec2 resultUV;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${depth}.0);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // max/min x(?, ?, d) to get y(yR, yC, d).\n      // ? = to be determined\n      float minMaxValue = 0.0;\n      float minMaxValueFound = 0.0;\n      float minMaxPosition = 0.0;\n      float avgValue = 0.0;\n\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n          float xTexC = xC * ${depth}.0 + d;\n\n          vec2 texCR = vec2(xTexC, xTexR);\n\n          // Check if the requested UV is invalid.\n          vec2 uv = (texCR + halfCR) / xShapeCR;\n          bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n          bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n          bool outside = lessThanZero || greaterThanOne;\n          if (outside) {\n            continue;\n          }\n\n          float value = texture2D(x, uv).r;\n          if (isNaN(value)) {\n            gl_FragColor = vec4(value, 0, 0, 0);\n            return;\n          }\n          if (${poolType === 'avg'}) {\n            avgValue += value / ${fSize * fSize}.0;\n          } else {\n            // If a min / max value has already been found, use it. If not, use\n            // the current value.\n            float currentMinMaxValue = mix(\n                value, minMaxValue, minMaxValueFound);\n            if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) {\n              minMaxValue = value;\n              minMaxValueFound = 1.0;\n              if (${computePositions}) {\n                minMaxPosition = wR * ${fSize}.0 + wC;\n              }\n            }\n          }\n        }\n      }\n      gl_FragColor = vec4(${returnValue}, 0, 0, 0);\n    }`;\n}\n\nexport function poolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float sum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          sum += texture2D(matrixA, uv).r;\n        }\n      }\n      gl_FragColor = vec4(sum, 0, 0, 0);\n    }`;\n}\n\nexport function reduceSum(\n    gpgpu: GPGPUContext, reduceSumProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(reduceSumProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadReduceSumDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0];\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getReluUnaryOp(): string {\n  return `\n    float result = (value < 0.0 ? 0.0 : value);\n    gl_FragColor = vec4(result, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp());\n}\n\nexport function relu(\n    gpgpu: GPGPUContext, reluProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result);\n}\n\nexport function uploadReluDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nimport * as webgl_util from './webgl_util';\n\nexport function getRenderRGBShader(\n    gpgpu: GPGPUContext, destinationWidth: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    const float destinationWidth = ${destinationWidth}.0;\n    const float a = 1.0;\n\n    void main() {\n      float xr = floor(resultUV.s * destinationWidth) * 3.0;\n      vec3 x = xr + vec3(0, 1, 2);\n\n      float sourceWidth = destinationWidth * 3.0;\n      vec3 u = (x + 0.5) / sourceWidth;\n      float v = 1.0 - resultUV.t;\n\n      float r = texture2D(source, vec2(u[0], v)).r;\n      float g = texture2D(source, vec2(u[1], v)).r;\n      float b = texture2D(source, vec2(u[2], v)).r;\n\n      gl_FragColor = vec4(r, g, b, a);\n    }`;\n\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function renderToCanvas(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  renderToFramebuffer(gpgpu, renderShader, sourceTex);\n}\n\nexport function renderToFramebuffer(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  gpgpu.setProgram(renderShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform vec2 inputDimCR;\n    uniform vec2 resultDimCR;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 resultCR = floor(resultUV * resultDimCR);\n      // indexInFlat = row * stride + column, where stride == numOutputColumns\n      float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n      vec2 inputCR = vec2(\n        mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n        floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n      ) + halfCR;\n\n      vec2 inputUV = inputCR / inputDimCR;\n      gl_FragColor = texture2D(matrixA, inputUV);\n    }`;\n}\n\nexport function reshape(\n    gpgpu: GPGPUContext, reshapeProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture,\n    resultNumRows: number, resultNumCols: number) {\n  const inputSize = aNumRows * aNumCols;\n  const outputSize = resultNumCols * resultNumRows;\n  util.assert(\n      inputSize === outputSize,\n      `The input size (${inputSize}) and output size (${outputSize}) ` +\n          `must match`);\n\n  gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols);\n  gpgpu.setProgram(reshapeProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n\n  const inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR');\n  gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows);\n\n  const resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR');\n  gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows);\n\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as webgl_util from './webgl_util';\n\nexport function getFragmentShaderSource(\n    inputShapeRCD: [number, number, number],\n    outputDimensionsRowCol: [number, number], alignCorners: boolean): string {\n  const depth = inputShapeRCD[2];\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n\n  const effectiveInputShapeRCD = alignCorners ?\n      [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] :\n      inputShapeRCD;\n\n  const effectiveOutputShapeRCD = alignCorners ?\n      [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] :\n      [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth];\n\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    const vec2 inputShapeCR = vec2(${inputShapeRCD[1]}, ${inputShapeRCD[0]});\n    const vec2 inputShapeTexCR = vec2(\n        ${inputTexShapeRC[1]}, ${inputTexShapeRC[0]});\n\n    const vec2 effectiveInputOverOutputRatioCR = vec2(\n        ${effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1]},\n        ${effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0]});\n\n    float sampleInput(float col, float row, float d) {\n      vec2 uv = (vec2(col * ${depth}.0 + d, row) + halfCR) / inputShapeTexCR;\n      return texture2D(matrixA, uv).r;\n    }\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n      vec2 yCR = vec2(floor(yTexCR.x / ${depth}.0), yTexCR.y);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      // Fractional source index.\n      vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n      // Compute the four integer indices.\n      vec2 sourceFloorCR = floor(sourceFracIndexCR);\n      vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n      float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n      float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n      float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n      float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n      vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n      float top = topLeft + (topRight - topLeft) * fracCR[0];\n      float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n      float newValue = top + (bottom - top) * fracCR[1];\n\n      gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function resizeBilinear(\n    gpgpu: GPGPUContext, resizeBilinearProgram: WebGLProgram, a: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(resizeBilinearProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {NDArray} from '../ndarray';\n\nexport type Input = {\n  name: string; array: NDArray;\n};\n\nexport function makeShaderKey(inputs: NDArray[], output: NDArray): string {\n  const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC());\n  return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC();\n}\n\nexport function makeShader(\n    inputs: Input[], output: NDArray, userCode: string): string {\n  const inputPrefixSnippet =\n      inputs.map(x => `uniform sampler2D ${x.name};`).join('\\n');\n  const inputSamplingSnippet =\n      inputs.map(x => getInputSamplingSnippet(x)).join('\\n');\n  const outTexShape = output.getTextureShapeRC();\n  const outputSamplingSnippet =\n      getOutputSamplingSnippet(output.shape, outTexShape);\n  const source = [\n    SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet,\n    outputSamplingSnippet, userCode\n  ].join('\\n');\n  return source;\n}\n\nfunction getInputSamplingSnippet(input: Input) {\n  const arr = input.array;\n  const shape = arr.shape;\n  const texShape = arr.getTextureShapeRC(shape as [number, number]);\n  switch (shape.length) {\n    case 2:\n      return getSampler2D(input.name, shape as [number, number], texShape);\n    default:\n      throw new Error(`${arr.rank}-D input sampling is not yet supported`);\n  }\n}\n\nfunction getOutputSamplingSnippet(\n    outShape: number[], outTexShape: [number, number]): string {\n  switch (outShape.length) {\n    case 2:\n      return getOutput2DCoords(outShape as [number, number], outTexShape);\n    default:\n      throw new Error(\n          `${outShape.length}-D output sampling is not yet supported`);\n  }\n}\n\nconst SHADER_PREFIX = `\n  precision highp float;\n  varying vec2 resultUV;\n  const vec2 halfCR = vec2(0.5, 0.5);\n\n  void setOutput(float val) {\n    gl_FragColor = vec4(val, 0, 0, 0);\n  }\n`;\n\nconst SAMPLE_2D_SNIPPET = `\n  float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n      float row, float col) {\n    float index = dot(vec2(row, col), vec2(numC, 1.0));\n    float texR = floor(index / texNumC);\n    float texC = mod(index, texNumC);\n    vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n    return texture2D(texture, uv).r;\n  }\n`;\n\nfunction getOutput2DCoords(\n    shape: [number, number], texShape: [number, number]) {\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      vec2 getOutputCoords() {\n        return floor(gl_FragCoord.yx);\n      }\n    `;\n  }\n  return `\n    vec2 getOutputCoords() {\n      vec2 resTexRC = floor(gl_FragCoord.yx);\n      float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0));\n      float r = floor(index / ${shape[1]}.0);\n      float c = mod(index, ${shape[1]}.0);\n      return vec2(r, c);\n    }\n  `;\n}\n\nfunction getSampler2D(\n    texName: string, shape: [number, number], texShape: [number, number]) {\n  const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1);\n  const tR = texShape[0];\n  const tC = texShape[1];\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      float ${funcName}(float row, float col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0);\n        return texture2D(${texName}, uv).r;\n      }\n    `;\n  }\n  return `\n    float ${funcName}(float row, float col) {\n      return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col);\n    }\n  `;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getSigmoidUnaryOp(): string {\n  return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);';\n}\n\nexport function getSigmoidFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp());\n}\n\nexport function sigmoid(\n    gpgpu: GPGPUContext, sigmoidProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result);\n}\n\nexport function uploadSigmoidDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(\n      a, rows, columns, getSigmoidUnaryOp());\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getStepUnaryOp(): string {\n  return `\n    float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n    gl_FragColor = vec4(res, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp());\n}\n\nexport function step(\n    gpgpu: GPGPUContext, stepProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result);\n}\n\nexport function uploadStepDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getUnpackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns, rows];\n}\n\nexport function getUnpackedArraySizeFromMatrixSize(\n    matrixSize: number, channelsPerTexture: number): number {\n  return matrixSize * channelsPerTexture;\n}\n\nexport function getColorMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns * 4, rows];\n}\n\nexport function getMatrixSizeFromUnpackedArraySize(\n    unpackedSize: number, channelsPerTexture: number): number {\n  if (unpackedSize % channelsPerTexture !== 0) {\n    throw new Error(\n        'unpackedSize (' + unpackedSize + ') must be a multiple of ' +\n        channelsPerTexture);\n  }\n  return unpackedSize / channelsPerTexture;\n}\n\nexport function encodeMatrixToUnpackedArray(\n    matrix: Float32Array, unpackedArray: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize =\n      getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);\n  if (unpackedArray.length < requiredSize) {\n    throw new Error(\n        'unpackedArray length (' + unpackedArray.length +\n        ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < matrix.length; ++src) {\n    unpackedArray[dst] = matrix[src];\n    dst += channelsPerTexture;\n  }\n}\n\nexport function decodeMatrixFromUnpackedArray(\n    unpackedArray: Float32Array, matrix: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize = getMatrixSizeFromUnpackedArraySize(\n      unpackedArray.length, channelsPerTexture);\n  if (matrix.length < requiredSize) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) {\n    matrix[dst++] = unpackedArray[src];\n  }\n}\n\nexport function getPackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [Math.ceil(columns / 2), Math.ceil(rows / 2)];\n}\n\nexport function getPackedRGBAArraySizeFromMatrixShape(\n    rows: number, columns: number): number {\n  const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  return w * h * 4;\n}\n\nexport function encodeMatrixToPackedRGBA(\n    matrix: Float32Array, rows: number, columns: number,\n    packedRGBA: Float32Array) {\n  const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);\n  if (packedRGBA.length < requiredSize) {\n    throw new Error(\n        'packedRGBA length (' + packedRGBA.length +\n        ') must be >= ' + requiredSize);\n  }\n  /*\n    Unpacked matrix, row-major order in Float32Array[16]:  A B C D\n                                                           E F G H\n                                                           I J K L\n                                                           M N O P\n\n    Packed matrix, 2x2 RGBA32 texture (memory view):       ABEF CDGH IJMN KLOP\n\n    Packed matrix, 2x2 RGBA32 texture (matrix view):       AB|CD\n                                                           EF|GH\n                                                           --+--\n                                                           IJ|KL\n                                                           MN|OP\n   */\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n\n  // loop over full 2x2 blocks\n  {\n    const dstStride = (oddWidth ? 4 : 0);\n    const oneRow = columns;\n    let dst = 0;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      const matrixSrcRow = (blockY * 2 * columns);\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        const matrixSrcCol = blockX * 2;\n        const src = matrixSrcRow + matrixSrcCol;\n        packedRGBA[dst] = matrix[src];\n        packedRGBA[dst + 1] = matrix[src + 1];\n        packedRGBA[dst + 2] = matrix[src + oneRow];\n        packedRGBA[dst + 3] = matrix[src + oneRow + 1];\n        dst += 4;\n      }\n      dst += dstStride;\n    }\n  }\n\n  // loop down final odd column\n  if (oddWidth) {\n    let src = columns - 1;\n    let dst = (textureWidth - 1) * 4;\n    const srcStride = 2 * columns;\n    const dstStride = textureWidth * 4;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      packedRGBA[dst] = matrix[src];\n      packedRGBA[dst + 2] = matrix[src + columns];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (rows - 1) * columns;\n    let dst = (textureHeight - 1) * textureWidth * 4;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      packedRGBA[dst++] = matrix[src++];\n      packedRGBA[dst++] = matrix[src++];\n      dst += 2;\n    }\n  }\n\n  // fill in bottom-right texel\n  if (oddWidth && oddHeight) {\n    packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];\n  }\n\n  return packedRGBA;\n}\n\nexport function decodeMatrixFromPackedRGBA(\n    packedRGBA: Float32Array, rows: number, columns: number,\n    matrix: Float32Array): Float32Array {\n  const requiredSize = rows * columns;\n  if (requiredSize < matrix.length) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  // loop over full 2x2 blocks\n  {\n    const srcStride = oddWidth ? 4 : 0;\n    const dstStride = columns + (oddWidth ? 1 : 0);\n    let src = 0;\n    let dstRow1 = 0;\n    let dstRow2 = columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n      }\n      src += srcStride;\n      dstRow1 += dstStride;\n      dstRow2 += dstStride;\n    }\n  }\n\n  // loop down final column\n  if (oddWidth) {\n    let src = (textureWidth - 1) * 4;\n    let dst = columns - 1;\n    const srcStride = textureWidth * 4;\n    const dstStride = 2 * columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      matrix[dst] = packedRGBA[src];\n      matrix[dst + columns] = packedRGBA[src + 2];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (textureHeight - 1) * textureWidth * 4;\n    let dst = (rows - 1) * columns;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      matrix[dst++] = packedRGBA[src++];\n      matrix[dst++] = packedRGBA[src++];\n      src += 2;\n    }\n  }\n\n  // fill in bottom-right cell\n  if (oddWidth && oddHeight) {\n    matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];\n  }\n\n  return matrix;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport class TextureManager {\n  private numUsedTextures = 0;\n  private numFreeTextures = 0;\n  private freeTextures: {[shape: string]: WebGLTexture[]} = {};\n  private logEnabled = false;\n  private usedTextureCount: {[shape: string]: number} = {};\n\n  constructor(private gpgpu: GPGPUContext) {}\n\n  acquireTexture(shapeRC: [number, number]): WebGLTexture {\n    const shapeKey = getKeyFromTextureShape(shapeRC);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    if (!(shapeKey in this.usedTextureCount)) {\n      this.usedTextureCount[shapeKey] = 0;\n    }\n    this.usedTextureCount[shapeKey]++;\n\n    if (this.freeTextures[shapeKey].length > 0) {\n      this.numFreeTextures--;\n      this.numUsedTextures++;\n      this.log();\n      return this.freeTextures[shapeKey].shift()!;\n    }\n    this.numUsedTextures++;\n    this.log();\n\n    return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]);\n  }\n\n  releaseTexture(texture: WebGLTexture, shape: [number, number]): void {\n    const shapeKey = getKeyFromTextureShape(shape);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    this.freeTextures[shapeKey].push(texture);\n    this.numFreeTextures++;\n    this.numUsedTextures--;\n    this.usedTextureCount[shapeKey]--;\n    this.log();\n  }\n\n  private log() {\n    if (!this.logEnabled) {\n      return;\n    }\n    const total = this.numFreeTextures + this.numUsedTextures;\n    console.log(\n        'Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures,\n        `(${total})`);\n  }\n\n  getNumUsedTextures(): number {\n    return this.numUsedTextures;\n  }\n\n  getNumFreeTextures(): number {\n    return this.numFreeTextures;\n  }\n\n  dispose() {\n    for (const shape in this.freeTextures) {\n      if (this.freeTextures.hasOwnProperty(shape)) {\n        for (let i = 0; i < this.freeTextures[shape].length; i++) {\n          this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]);\n        }\n      }\n    }\n  }\n}\n\nfunction getKeyFromTextureShape(shapeRowsCol: [number, number]): string {\n  return shapeRowsCol[0] + '_' + shapeRowsCol[1];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\n/**\n * Sine\n */\nfunction getSinUnaryOp(): string {\n  return `\n    gl_FragColor = vec4(sin(value), 0, 0, 0);\n  `;\n}\n\nexport function getSinFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp());\n}\n\nexport function sin(\n    gpgpu: GPGPUContext, sinProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result);\n}\n\nexport function uploadSinDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp());\n}\n\n/**\n * Tanh\n */\nfunction getTanhUnaryOp(): string {\n  return `\n    float e2x = exp(-2.0 * value);\n    gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n  `;\n}\n\nexport function getTanhFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp());\n}\n\nexport function tanh(\n    gpgpu: GPGPUContext, tanhProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result);\n}\n\nexport function uploadTanhDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(resultOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    void main() {\n      float value = texture2D(matrixA, resultUV).r;\n      ${resultOp}\n    }`;\n}\n\nexport function unaryOp(\n    gpgpu: GPGPUContext, unaryOpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(unaryOpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadUnaryOpDownload(\n    a: Float32Array, rows: number, columns: number,\n    resultOp: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const fragmentShaderSrc = getFragmentShaderSource(resultOp);\n  const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSrc);\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nlet USE_WEBGL2_WHEN_AVAILABLE = false;\nlet WEBGL2_ENABLED: boolean|undefined = null!;\nlet MAX_TEXTURE_SIZE: number = null!;\n\nimport * as util from '../../util';\n\nexport interface WebGLContextAttributes {\n  alpha?: boolean;\n  antialias?: boolean;\n  premultipliedAlpha?: boolean;\n  preserveDrawingBuffer?: boolean;\n  depth?: boolean;\n  stencil?: boolean;\n  failIfMajorPerformanceCaveat?: boolean;\n}\n\n/** @hidden */\nexport const IS_NAN_SHADER_FUNC = `\nbool isNaN(float val) {\n  return val == val ? false : true;\n}\n`;\n\nexport interface WebGLLoseContextExtension { loseContext(): void; }\n\nexport function createWebGLRenderingContext(attributes: WebGLContextAttributes):\n    WebGLRenderingContext {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return createWebGLRenderingContextFromCanvas(canvas, attributes);\n}\n\n/**\n * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL\n * 2.0 is available.\n */\nexport function preferWebGL1() {\n  USE_WEBGL2_WHEN_AVAILABLE = false;\n  WEBGL2_ENABLED = undefined;\n}\n\n/**\n * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration.\n */\nexport function preferWebGL2() {\n  USE_WEBGL2_WHEN_AVAILABLE = true;\n  WEBGL2_ENABLED = undefined;\n}\n\nexport function isWebGL2Enabled() {\n  if (!USE_WEBGL2_WHEN_AVAILABLE) {\n    return false;\n  }\n\n  if (WEBGL2_ENABLED === undefined) {\n    const tempCanvas = document.createElement('canvas');\n    const gl = tempCanvas.getContext('webgl2');\n    if (gl != null) {\n      WEBGL2_ENABLED = true;\n\n      const loseContextExtension =\n          getExtensionOrThrow(\n              gl as WebGLRenderingContext, 'WEBGL_lose_context') as\n          WebGLLoseContextExtension;\n      loseContextExtension.loseContext();\n    } else {\n      WEBGL2_ENABLED = false;\n    }\n  }\n  return WEBGL2_ENABLED;\n}\n\nexport function createWebGLRenderingContextFromCanvas(\n    canvas: HTMLCanvasElement,\n    attributes: WebGLContextAttributes): WebGLRenderingContext {\n  let gl: WebGLRenderingContext;\n  if (isWebGL2Enabled()) {\n    gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext;\n  } else {\n    gl = (canvas.getContext('webgl', attributes) ||\n          canvas.getContext('experimental-webgl', attributes)) as\n        WebGLRenderingContext;\n  }\n\n  if (gl == null) {\n    throw new Error('This browser does not support WebGL.');\n  }\n  return gl;\n}\n\nexport function callAndCheck<T>(gl: WebGLRenderingContext, func: () => T): T {\n  const returnValue = func();\n  checkWebGLError(gl);\n  return returnValue;\n}\n\nlet webGLDebugErrorCheckingEnabled = false;\n\nexport function enableDebugWebGLErrorChecking(enabled: boolean) {\n  webGLDebugErrorCheckingEnabled = enabled;\n}\n\nexport function checkWebGLError(gl: WebGLRenderingContext) {\n  if (webGLDebugErrorCheckingEnabled) {\n    const error = gl.getError();\n    if (error !== gl.NO_ERROR) {\n      throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error));\n    }\n  }\n}\n\nexport function getWebGLErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.NO_ERROR:\n      return 'NO_ERROR';\n    case gl.INVALID_ENUM:\n      return 'INVALID_ENUM';\n    case gl.INVALID_VALUE:\n      return 'INVALID_VALUE';\n    case gl.INVALID_OPERATION:\n      return 'INVALID_OPERATION';\n    case gl.INVALID_FRAMEBUFFER_OPERATION:\n      return 'INVALID_FRAMEBUFFER_OPERATION';\n    case gl.OUT_OF_MEMORY:\n      return 'OUT_OF_MEMORY';\n    case gl.CONTEXT_LOST_WEBGL:\n      return 'CONTEXT_LOST_WEBGL';\n    default:\n      return 'Unknown error code ' + status;\n  }\n}\n\nexport function getExtensionOrThrow(\n    gl: WebGLRenderingContext, extensionName: string): {} {\n  return throwIfNull<{}>(\n      gl, () => gl.getExtension(extensionName),\n      'Extension \"' + extensionName + '\" not supported on this browser.');\n}\n\nexport function createVertexShader(\n    gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader {\n  const vertexShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.VERTEX_SHADER),\n      'Unable to create vertex WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource));\n  callAndCheck(gl, () => gl.compileShader(vertexShader));\n  if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(vertexShader));\n    throw new Error('Failed to compile vertex shader.');\n  }\n  return vertexShader;\n}\n\nexport function createFragmentShader(\n    gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader {\n  const fragmentShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.FRAGMENT_SHADER),\n      'Unable to create fragment WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource));\n  callAndCheck(gl, () => gl.compileShader(fragmentShader));\n  if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(fragmentShader));\n    throw new Error('Failed to compile fragment shader.');\n  }\n  return fragmentShader;\n}\n\nexport function createProgram(gl: WebGLRenderingContext): WebGLProgram {\n  return throwIfNull<WebGLProgram>(\n      gl, () => gl.createProgram(), 'Unable to create WebGLProgram.');\n}\n\nexport function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.linkProgram(program));\n  if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Failed to link vertex and fragment shaders.');\n  }\n}\n\nexport function validateProgram(\n    gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.validateProgram(program));\n  if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Shader program validation failed.');\n  }\n}\n\nexport function createStaticVertexBuffer(\n    gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function createStaticIndexBuffer(\n    gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function queryMaxTextureSize(gl: WebGLRenderingContext): number {\n  if (MAX_TEXTURE_SIZE != null) {\n    return MAX_TEXTURE_SIZE;\n  }\n  MAX_TEXTURE_SIZE =\n      callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE));\n  return MAX_TEXTURE_SIZE;\n}\n\nexport function getChannelsPerTexture(): number {\n  if (isWebGL2Enabled()) {\n    return 1;\n  }\n  return 4;\n}\n\nexport function createTexture(gl: WebGLRenderingContext): WebGLTexture {\n  return throwIfNull<WebGLTexture>(\n      gl, () => gl.createTexture(), 'Unable to create WebGLTexture.');\n}\n\nexport function validateTextureSize(\n    gl: WebGLRenderingContext, width: number, height: number) {\n  const maxTextureSize: number = queryMaxTextureSize(gl);\n  if ((width <= 0) || (height <= 0)) {\n    const requested = '[' + width + 'x' + height + ']';\n    throw new Error('Requested texture size ' + requested + ' is invalid.');\n  }\n  if ((width > maxTextureSize) || (height > maxTextureSize)) {\n    const requested = '[' + width + 'x' + height + ']';\n    const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']';\n    throw new Error(\n        'Requested texture size ' + requested +\n        ' greater than WebGL maximum on this browser / GPU ' + max + '.');\n  }\n}\n\nexport function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer {\n  return throwIfNull<WebGLFramebuffer>(\n      gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.');\n}\n\nexport function bindVertexBufferToProgramAttribute(\n    gl: WebGLRenderingContext, program: WebGLProgram, attribute: string,\n    buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number,\n    itemOffsetInBytes: number) {\n  const loc = gl.getAttribLocation(program, attribute);\n  if (loc === -1) {\n    const error = new Error(\n        'Unable to get attribute \"' + attribute + '\" on WebGLProgram.');\n    // tslint:disable-next-line:no-any\n    (error as any).namedVertexAttributeNotFound = attribute;\n    throw error;\n  }\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl,\n      () => gl.vertexAttribPointer(\n          loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes,\n          itemOffsetInBytes));\n  callAndCheck(gl, () => gl.enableVertexAttribArray(loc));\n}\n\nexport function bindTextureUnit(\n    gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n}\n\nexport function unbindTextureUnit(\n    gl: WebGLRenderingContext, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function getProgramUniformLocationOrThrow(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    uniformName: string): WebGLUniformLocation {\n  return throwIfNull<WebGLUniformLocation>(\n      gl, () => gl.getUniformLocation(program, uniformName),\n      'uniform \"' + uniformName + '\" not present in program.');\n}\n\nexport function bindTextureToProgramUniformSampler(\n    gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture,\n    uniformSamplerName: string, textureUnit: number) {\n  callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit));\n  const samplerLocation =\n      getProgramUniformLocationOrThrow(gl, program, uniformSamplerName);\n  callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit));\n}\n\nexport function bindCanvasToFramebuffer(gl: WebGLRenderingContext) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n  callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height));\n  callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height));\n}\n\nexport function bindColorTextureToFramebuffer(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0));\n}\n\nexport function unbindColorTextureFromFramebuffer(\n    gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0));\n}\n\nexport function validateFramebuffer(gl: WebGLRenderingContext) {\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new Error(\n        'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status));\n  }\n}\n\nexport function getFramebufferErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n      return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS';\n    case gl.FRAMEBUFFER_UNSUPPORTED:\n      return 'FRAMEBUFFER_UNSUPPORTED';\n    default:\n      return 'unknown error ' + status;\n  }\n}\n\nfunction throwIfNull<T>(\n    gl: WebGLRenderingContext, returnTOrNull: () => T | null,\n    failureMessage: string): T {\n  const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull());\n  if (tOrNull == null) {\n    throw new Error(failureMessage);\n  }\n  return tOrNull as T;\n}\n\nfunction validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) {\n  const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;\n  const glTextureUnit = textureUnit + gl.TEXTURE0;\n  if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) {\n    const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']';\n    throw new Error('textureUnit must be in ' + textureUnitRange + '.');\n  }\n}\n\nexport function getTextureShapeFromLogicalShape(\n    gl: WebGLRenderingContext, logicalShape: number[],\n    preferredTexShape?: [number, number]): [number, number] {\n  const maxTexSize = queryMaxTextureSize(gl);\n  const size = util.sizeFromShape(logicalShape);\n  if (preferredTexShape != null) {\n    const sizePreferred = util.sizeFromShape(preferredTexShape);\n    util.assert(\n        size === sizePreferred,\n        `Size of shape (${size}) must match size of ` +\n            `preferredShape (${sizePreferred})`);\n    if (preferredTexShape[0] <= maxTexSize &&\n        preferredTexShape[1] <= maxTexSize) {\n      return preferredTexShape;\n    }\n  }\n\n  if (logicalShape.length <= 1 && size <= maxTexSize) {\n    return [size, 1];\n  } else if (\n      logicalShape.length === 2 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] <= maxTexSize) {\n    return logicalShape as [number, number];\n  } else if (\n      logicalShape.length === 3 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] * logicalShape[2] <= maxTexSize) {\n    return [logicalShape[0], logicalShape[1] * logicalShape[2]];\n  } else {\n    return util.sizeToSquarishShape(size);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {AddNode, ArgMaxEqualsNode, ArgMaxNode, Concat3DNode, Convolution2DNode, DivideNode, ExpNode, FusedLinearCombinationNode, Graph, LogNode, MatMulNode, MaxPoolNode, MeanSquaredCostNode, MultiplyNode, Node, ReduceSumNode, ReLUNode, ReshapeNode, SigmoidNode, SoftmaxCrossEntropyCostNode, SoftmaxNode, SplitNode, SquareNode, SubtractNode, TanHNode, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {Add} from './ops/add';\nimport {ArgMax} from './ops/argmax';\nimport {ArgMaxEquals} from './ops/argmaxequals';\nimport {Concat3D} from './ops/concat3d';\nimport {Convolution2D} from './ops/convolution';\nimport {Divide} from './ops/divide';\nimport {ReLU, Sigmoid, Square, TanH} from './ops/element_wise_activation';\nimport {MeanSquaredCost} from './ops/element_wise_cost';\nimport {Exp} from './ops/exp';\nimport {LinearCombination} from './ops/linear_combination';\nimport {Log} from './ops/log';\nimport {MatMul} from './ops/matmul';\nimport {MaxPool} from './ops/max_pool';\nimport {Multiply} from './ops/multiply';\nimport {Operation} from './ops/op';\nimport {ReduceSum} from './ops/reduce_sum';\nimport {Reshape} from './ops/reshape';\nimport {Softmax, SoftmaxCrossEntropyCost} from './ops/softmax';\nimport {Split} from './ops/split';\nimport {Subtract} from './ops/subtract';\n\nexport function emitFromGraphNodes(nodes: Node[]): Operation[] {\n  const ops: Operation[] = [];\n  nodes.forEach(node => Array.prototype.push.apply(ops, emitOpFromNode(node)));\n  return ops;\n}\n\nfunction emitOpFromNode(node: Node): Operation[] {\n  if (node instanceof ReshapeNode) {\n    return [new Reshape(node.inputs[ReshapeNode.X], node.output)];\n  } else if (node instanceof MatMulNode) {\n    const x1 = node.inputs[MatMulNode.X1];\n    const x2 = node.inputs[MatMulNode.X2];\n    return [new MatMul(x1, x2, node.output)];\n  } else if (node instanceof Convolution2DNode) {\n    const w = node.inputs[Convolution2DNode.W];\n    const x = node.inputs[Convolution2DNode.X];\n    const b = node.inputs[Convolution2DNode.B];\n    return [new Convolution2D(\n        w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride,\n        node.zeroPad)];\n  } else if (node instanceof MaxPoolNode) {\n    const x = node.inputs[MaxPoolNode.X];\n    return [new MaxPool(\n        x, node.output, node.fieldSize, node.stride, node.zeroPad)];\n  } else if (node instanceof ExpNode) {\n    return [new Exp(node.inputs[ExpNode.X], node.output)];\n  } else if (node instanceof LogNode) {\n    return [new Log(node.inputs[LogNode.X], node.output)];\n  } else if (node instanceof ReLUNode) {\n    return [new ReLU(node.inputs[ReLUNode.X], node.output)];\n  } else if (node instanceof TanHNode) {\n    return [new TanH(node.inputs[TanHNode.X], node.output)];\n  } else if (node instanceof SigmoidNode) {\n    return [new Sigmoid(node.inputs[SigmoidNode.X], node.output)];\n  } else if (node instanceof SoftmaxCrossEntropyCostNode) {\n    const x = node.inputs[SoftmaxCrossEntropyCostNode.X];\n    const target = node.inputs[SoftmaxCrossEntropyCostNode.TARGET];\n    return [new SoftmaxCrossEntropyCost(x, target, node.output)];\n  } else if (node instanceof SoftmaxNode) {\n    return [new Softmax(node.inputs[SoftmaxNode.X], node.output)];\n  } else if (node instanceof MeanSquaredCostNode) {\n    const label = node.inputs[MeanSquaredCostNode.LABEL];\n    const prediction = node.inputs[MeanSquaredCostNode.PREDICTION];\n    return [new MeanSquaredCost(label, prediction, node.output)];\n  } else if (node instanceof ArgMaxEqualsNode) {\n    return [new ArgMaxEquals(\n        node.inputs[ArgMaxEqualsNode.X1], node.inputs[ArgMaxEqualsNode.X2],\n        node.output)];\n  } else if (node instanceof ArgMaxNode) {\n    return [new ArgMax(node.x, node.output)];\n  } else if (node instanceof FusedLinearCombinationNode) {\n    return [new LinearCombination(\n        node.inputs[FusedLinearCombinationNode.T1],\n        node.inputs[FusedLinearCombinationNode.T2],\n        node.inputs[FusedLinearCombinationNode.C1],\n        node.inputs[FusedLinearCombinationNode.C2], node.output)];\n  } else if (node instanceof Concat3DNode) {\n    return [new Concat3D(\n        node.inputs[Concat3DNode.X1], node.inputs[Concat3DNode.X2], node.axis,\n        node.output)];\n  } else if (node instanceof SquareNode) {\n    return [new Square(node.inputs[SquareNode.X], node.output)];\n  } else if (node instanceof AddNode) {\n    return [new Add(\n        node.inputs[AddNode.T1], node.inputs[AddNode.T2], node.output)];\n  } else if (node instanceof SubtractNode) {\n    return [new Subtract(\n        node.inputs[SubtractNode.T1], node.inputs[SubtractNode.T2],\n        node.output)];\n  } else if (node instanceof MultiplyNode) {\n    return [new Multiply(\n        node.inputs[MultiplyNode.T1], node.inputs[MultiplyNode.T2],\n        node.output)];\n  } else if (node instanceof DivideNode) {\n    return [new Divide(\n        node.inputs[DivideNode.T1], node.inputs[DivideNode.T2], node.output)];\n  } else if (node instanceof SplitNode) {\n    return [new Split(node.inputs[SplitNode.X], node.outputs)];\n  } else if (node instanceof ReduceSumNode) {\n    return [new ReduceSum(node.inputs[ReduceSumNode.X], node.output)];\n  } else if (graph_util.isInputNode(node)) {\n    return [];\n  } else {\n    // tslint:disable-next-line:no-any\n    throw Error('Unsupported node type: ' + (node.constructor as any).name);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Add extends Operation {\n  private dySizeScalar: Scalar;\n\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(x1.shape)) {\n        result = math.scalarPlusArray(x1, x2);\n      } else if (util.isScalarShape(x2.shape)) {\n        result = math.scalarPlusArray(x2, x1);\n      } else {\n        result = math.add(x1, x2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x1Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x1Tensor, dy);\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x2Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x2Tensor, dy);\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMax extends Operation {\n  /**\n   * An ArgMax operation.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMax(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMax backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMaxEquals extends Operation {\n  /**\n   * An ArgMaxEquals operation.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMaxEquals(x1, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMaxEquals backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as concat3d_util from '../math/concat3d_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Concat3D extends Operation {\n  /**\n   * A Concat 3D operation.\n   *\n   * Concats two 3D tensors along an axis.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor, private axis: number,\n      private yTensor: Tensor) {\n    super();\n    concat3d_util.assertConcat3DShapesMatch(\n        x1Tensor.shape, x2Tensor.shape, axis);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor) as Array3D;\n    const x2 = inferenceArrays.get(this.x2Tensor) as Array3D;\n\n    math.scope((keep) => {\n      const concatResult = math.concat3D(x1, x2, this.axis);\n      inferenceArrays.set(this.yTensor, keep(concatResult));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('Concat3D backprop not implemented.');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Convolution2D extends Operation {\n  private zeroPad: number;\n\n  /**\n   * Constructs a convolution op with the specified properties.\n   *\n   * @param inputShape The shape of the input ndarray.\n   * @param fieldSize The size of the filter (rows/cols of sliding window).\n   * @param outputDepth The depth of the output (Number of filters).\n   * @param stride How many pixels to shift the filter by when sliding.\n   *     Defaults to 1.\n   * @param zeroPad How many pixels to pad the input from each side. Defaults to\n   *     a value so that the rows and columns of the output ndarray is\n   *     the same as the input ndarray.\n   * @param weights Optional. The weights of the filters.\n   * @param biases Optional. The bias terms of the filters.\n   */\n  constructor(\n      private wTensor: Tensor, private xTensor: Tensor, private bTensor: Tensor,\n      private yTensor: Tensor, private fieldSize: number,\n      private outputDepth: number, private stride = 1, zeroPad?: number) {\n    super();\n    this.assertWeightsShape(wTensor.shape);\n    this.zeroPad = zeroPad != null ?\n        zeroPad :\n        conv_util.computeDefaultPad(\n            this.xTensor.shape as [number, number, number], this.fieldSize,\n            this.stride);\n    util.assert(\n        util.isInt(this.zeroPad),\n        `The zero padding (${this.zeroPad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const biases = inferenceArrays.get(this.bTensor) as Array1D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.conv2d(x, weights, biases, this.stride, this.zeroPad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      const {dw, db, dx} =\n          math.conv2dBackProp(x, dy, weights, this.stride, this.zeroPad);\n      gradientArrays.set(this.wTensor, keep(dw));\n      gradientArrays.set(this.bTensor, keep(db));\n      gradientArrays.set(this.xTensor, keep(dx));\n    });\n  }\n\n  private assertWeightsShape(weightsShape: number[]) {\n    util.assert(\n        weightsShape[0] === this.fieldSize &&\n            weightsShape[1] === this.fieldSize &&\n            weightsShape[2] === this.xTensor.shape[2] &&\n            weightsShape[3] === this.outputDepth,\n        `weights must be of shape [${this.fieldSize},${this.fieldSize},` +\n            `${this.xTensor.shape[2]},${this.outputDepth}] but they are of` +\n            `shape [${weightsShape}]`);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Divide extends Operation {\n  private ones: NDArray;\n\n  /**\n   * Element-wise divide operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarDividedByArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayDividedByScalar(t1, t2);\n      } else {\n        result = math.divide(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    const x1IsScalar = util.isScalarShape(x1.shape);\n    const x2IsScalar = util.isScalarShape(x2.shape);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (x1IsScalar) {\n          const div = math.divide(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(div)));\n\n          div.dispose();\n        } else if (x2IsScalar) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.divide(dy, x2)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        // dx2 = -1 * x1 * x2 ^ -2.\n        const x2Squared = math.elementWiseMul(x2, x2);\n\n        let x1OverX2Squared: NDArray;\n        if (x2IsScalar) {\n          x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared);\n        } else if (x1IsScalar) {\n          x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared);\n        } else {\n          x1OverX2Squared = math.divide(x1, x2Squared);\n        }\n\n        const dx2 = math.neg(x1OverX2Squared);\n        const dyTimesDerivative = math.elementWiseMul(dy, dx2);\n\n        if (x2IsScalar) {\n          gradientArrays.set(this.x2Tensor, keep(math.sum(dyTimesDerivative)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(dyTimesDerivative));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {ActivationFunction, ReLUFunc, SigmoidFunc, SquareFunc, TanHFunc} from '../math/activation_functions';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseActivation extends Operation {\n  constructor(\n      protected xTensor: Tensor, protected yTensor: Tensor,\n      private func: ActivationFunction) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(this.func.output(math, x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    // dE/dx_i = sum_j dE/dy_j * dy_j/dx_i\n    //         = dE/dy_i * dy_i/dx_i\n    const x = inferenceArrays.get(this.xTensor);\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      const dydx = this.func.der(math, x, y);\n      gradientArrays.set(this.xTensor, keep(math.elementWiseMul(dy, dydx)));\n      dydx.dispose();\n    });\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReLU extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new ReLUFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class TanH extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new TanHFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Sigmoid extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SigmoidFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Square extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SquareFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {ElementWiseCostFunction, SquareCostFunc} from '../math/cost_functions';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseCost<T extends NDArray> extends Operation {\n  private oneOverNScalar: Scalar;\n\n  constructor(\n      protected x1Tensor: Tensor, protected x2Tensor: Tensor,\n      protected yTensor: Tensor, protected func: ElementWiseCostFunction) {\n    super();\n    this.oneOverNScalar = Scalar.new(1 / util.sizeFromShape(x1Tensor.shape));\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      const elementWiseCost = this.func.cost(math, x1, x2);\n      const sum = math.sum(elementWiseCost);\n      const result = math.scalarTimesArray(this.oneOverNScalar, sum);\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(this.func.der(math, x1, x2)));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(this.func.der(math, x2, x1)));\n      }\n    });\n  }\n\n  dispose() {\n    this.func.dispose();\n    this.oneOverNScalar.dispose();\n  }\n}\n\n/**\n * @hidden\n */\nexport class MeanSquaredCost extends ElementWiseCost<Array1D> {\n  constructor(x1Tensor: Tensor, x2Tensor: Tensor, yTensor: Tensor) {\n    super(x1Tensor, x2Tensor, yTensor, new SquareCostFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Exp extends Operation {\n  /**\n   * Exponentation operation - e^x.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.exp(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.elementWiseMul(y, dy)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class LinearCombination extends Operation {\n  /**\n   * A 2-tensor linear combination operation.\n   *\n   * Combines tensors x1 and x2 (of the same shape) with weights c1 & c2;\n   * Computes c1*x1 + c2*x2.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private c1Tensor: Tensor, private c2Tensor: Tensor,\n      private outTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor).asScalar();\n    const c2 = inferenceArrays.get(this.c2Tensor).asScalar();\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor);\n    const c2 = inferenceArrays.get(this.c2Tensor);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(math.scalarTimesArray(c1, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(math.scalarTimesArray(c2, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.c1Tensor)) {\n        const dotProduct1 = math.elementWiseMul(x1, dy);\n        gradientArrays.set(this.c1Tensor, keep(math.sum(dotProduct1)));\n      }\n\n      if (graph_util.shouldBackProp(this.c2Tensor)) {\n        const dotProduct2 = math.elementWiseMul(x2, dy);\n        gradientArrays.set(this.c2Tensor, keep(math.sum(dotProduct2)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Log extends Operation {\n  /**\n   * Natural log operation - ln(x)\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.log(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.divide(dy, x)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MatMul extends Operation {\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (x1.shape.length === 2 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor, keep(math.matMul(x1 as Array2D, x2 as Array2D)));\n      } else if (x1.shape.length === 2 && x2.shape.length === 1) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.matrixTimesVector(x1 as Array2D, x2 as Array1D)));\n      } else if (x1.shape.length === 1 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.vectorTimesMatrix(x1 as Array1D, x2 as Array2D)));\n      }\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    let x1 = inferenceArrays.get(this.x1Tensor);\n    let x2 = inferenceArrays.get(this.x2Tensor);\n    let dy = gradientArrays.get(this.yTensor);\n\n    if (x1.shape.length === 1) {\n      x1 = x1.reshape([1, x1.size]);\n      dy = dy.reshape([1, dy.size]);\n    }\n    if (x2.shape.length === 1) {\n      x2 = x2.reshape([x2.size, 1]);\n      dy = dy.reshape([dy.size, 1]);\n    }\n\n    math.scope((keep) => {\n      // y = x1 * x2\n      // dx1 = dy * x2T\n      // dx2 = x1T * dy\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        const dx1 = math.matMul(\n            dy as Array2D, x2 as Array2D, MatrixOrientation.REGULAR,\n            MatrixOrientation.TRANSPOSED);\n        gradientArrays.set(\n            this.x1Tensor,\n            keep(this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        const dx2 = math.matMul(\n            x1 as Array2D, dy as Array2D, MatrixOrientation.TRANSPOSED,\n            MatrixOrientation.REGULAR);\n        gradientArrays.set(\n            this.x2Tensor,\n            keep(this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array2D, Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MaxPool extends Operation {\n  private pad: number;\n\n  constructor(\n      private xTensor: Tensor, private yTensor: Tensor,\n      private fieldSize: number, private stride = 1, pad?: number) {\n    super();\n\n    if (pad != null) {\n      this.pad = pad;\n    } else {\n      this.pad = conv_util.computeDefaultPad(\n          xTensor.shape as [number, number, number], this.fieldSize,\n          this.stride);\n    }\n\n    util.assert(\n        util.isInt(this.pad),\n        `The zero padding (${this.pad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.maxPool(x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor,\n          keep(math.maxPoolBackprop(\n              dy, x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Multiply extends Operation {\n  /**\n   * Element-wise multiply operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarTimesArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.scalarTimesArray(t2, t1);\n      } else {\n        result = math.elementWiseMul(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x2.shape)) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.scalarTimesArray(x2, dy)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.elementWiseMul(x2, dy)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x1);\n\n          gradientArrays.set(this.x2Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x1.shape)) {\n          gradientArrays.set(\n              this.x2Tensor, keep(math.scalarTimesArray(x1, dy)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(math.elementWiseMul(x1, dy)));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\n/**\n * @hidden\n */\nexport abstract class Operation {\n  abstract feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap):\n      void;\n\n  abstract backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap): void;\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {}\n\n  dispose() {}\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ReduceSum extends Operation {\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(private x: Tensor, private outTensor: Tensor) {\n    super();\n    util.assertShapesMatch(outTensor.shape, []);\n  }\n\n  private ones: NDArray;\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.x);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.outTensor, keep(math.sum(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.x)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      const dy = gradientArrays.get(this.outTensor);\n      if (this.ones == null) {\n        const xArray = inferenceArrays.get(this.x);\n        this.ones = NDArray.zerosLike(xArray);\n        this.ones.fill(1);\n      }\n      gradientArrays.set(this.x, keep(math.scalarTimesArray(dy, this.ones)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Reshape<T1 extends NDArray, T2 extends NDArray> extends Operation {\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n    const xSize = util.sizeFromShape(xTensor.shape);\n    const ySize = util.sizeFromShape(yTensor.shape);\n    util.assert(\n        xSize === ySize,\n        `The input size (${xSize}) and output size (${ySize}) must match`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as T1;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor, keep(math.reshape<T1, T2>(x, this.yTensor.shape)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const dy = gradientArrays.get(this.yTensor) as T2;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor, keep(math.reshape<T2, T1>(dy, this.xTensor.shape)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Softmax extends Operation {\n  constructor(private logitsTensor: Tensor, private output: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    return math.scope((keep) => {\n      inferenceArrays.set(this.output, keep(math.softmax(logits)));\n    });\n  }\n\n  backProp() {\n    throw Error('Softmax backprop is not yet implemented');\n  }\n}\n\nexport class SoftmaxCrossEntropyCost extends Operation {\n  constructor(\n      private logitsTensor: Tensor, private labelTensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    this.softmaxTensor = new Tensor(logitsTensor.shape);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    const label = inferenceArrays.get(this.labelTensor) as Array1D;\n\n    math.scope((keep) => {\n      const softmaxResult = math.softmax(logits);\n\n      inferenceArrays.set(this.softmaxTensor, keep(softmaxResult));\n      inferenceArrays.set(\n          this.yTensor,\n          keep(crossEntropyCost(math, softmaxResult, label, this.epsilon)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const softmax = inferenceArrays.get(this.softmaxTensor);\n    const label = inferenceArrays.get(this.labelTensor);\n\n    math.scope((keep) => {\n      gradientArrays.set(this.logitsTensor, keep(math.sub(softmax, label)));\n    });\n  }\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {\n    inferenceArrays.disposeArray(this.softmaxTensor);\n  }\n\n  dispose() {\n    this.epsilon.dispose();\n  }\n\n  private softmaxTensor: Tensor;\n  private epsilon = Scalar.new(1e-5);\n}\n\nexport function crossEntropyCost(\n    math: NDArrayMath, y: Array1D, target: Array1D, epsilon: Scalar): Scalar {\n  util.assert(\n      y.size === target.size, 'The output and target must be the same size');\n\n  return math.scope(() => {\n    const yPlusEps = math.scalarPlusArray(epsilon, y);\n    const logOutput = math.log(yPlusEps);\n    const tarLogOutput = math.elementWiseMul(target, logOutput);\n    const costVector = math.neg(tarLogOutput);\n    return math.sum(costVector);\n  });\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * Split ops are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n */\nexport class Split extends Operation {\n  constructor(private input: Tensor, private outputs: Tensor[]) {\n    super();\n    outputs.forEach(output => {\n      util.assertShapesMatch(input.shape, output.shape);\n    });\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const inputArray = inferenceArrays.get(this.input);\n    this.outputs.forEach(output => {\n      inferenceArrays.set(output, inputArray);\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.input)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      let dx = math.add(\n          gradientArrays.get(this.outputs[0]),\n          gradientArrays.get(this.outputs[1]));\n      // Sum across all the derivatives of the consumers of this node.\n      this.outputs.slice(2).forEach(output => {\n        dx = math.add(dx, gradientArrays.get(output));\n      });\n      gradientArrays.set(this.input, keep(dx));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Subtract extends Operation {\n  private dySizeScalar: Scalar;\n\n  /**\n   * Element-wise subtract operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private t1: Tensor, private t2: Tensor, private outTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(t1.shape) === 1 ||\n            util.sizeFromShape(t2.shape) === 1 ||\n            util.arraysEqual(t1.shape, t2.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarMinusArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayMinusScalar(t1, t2);\n      } else {\n        result = math.sub(t1, t2);\n      }\n      inferenceArrays.set(this.outTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.t1)) {\n        if (util.isScalarShape(this.t1.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t1, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t1, keep(dy));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.t2)) {\n        if (util.isScalarShape(this.t2.shape)) {\n          const sum = math.sum(dy);\n          const negSum = math.neg(sum);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t2, keep(math.divide(negSum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t2, keep(math.neg(dy)));\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {SessionRuntime} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport abstract class Optimizer {\n  protected variableNodes: VariableNode[];\n  protected specifiedVariableNodes: VariableNode[]|null;\n\n  constructor(specifiedVariableList?: Node[]) {\n    if (specifiedVariableList != null) {\n      this.specifiedVariableNodes = specifiedVariableList as VariableNode[];\n    }\n  }\n\n  abstract beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract dispose(): void;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * Default comparison function for the priority queue.\n * @param a The first element to compare.\n * @param b The second element to compare.\n * @return \"a > b\" returns > 0. \"a < b\" returns < 0. \"a === b\" returns 0.\n */\nexport function defaultCompare<T>(a: T, b: T): number {\n  if (a === b) {\n    return 0;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * A Comparator is a user-provided function that compares two T instances. The\n * convention for defaultCompare is expected to be followed to maintain the\n * binary min-heap integrity.\n * @param a The first element to compare.\n * @param b The second element to compare.\n */\nexport type Comparator<T> = (a: T, b: T) => number;\n\n/**\n * IndexObserver is a user-provided callback that informs the caller when an\n * element in the priority queue's binary min-heap has been relocated.\n * @param t The element that was relocated.\n * @param newIndex The new location in the binary min-heap of the element.\n */\nexport type IndexObserver<T> = (t: T, newIndex: number) => void;\n\n/**\n * A priority queue, implemented in terms of a binary min-heap. Lower priority\n * numbers are considered higher priority.\n * enqueue, dequeue, and update are all O(log N) with respect to the number of\n * elements in the queue.\n */\nexport class PriorityQueue<T> {\n  private heap: T[] = [];\n\n  /**\n   * @param comparator A function that compares two queue elements.\n   * @param indexObserver An optional callback raised when the priority queue\n   * changes the order of elements in its min-heap. Useful for tracking the\n   * positions of elements that need updating.\n   */\n  constructor(\n      private comparator: Comparator<T>,\n      private indexObserver?: IndexObserver<T>) {}\n\n  /**\n   * Add an element to the priority queue.\n   * @param t The element to enqueue.\n   */\n  enqueue(t: T) {\n    this.heap.push(t);\n    this.onIndexChanged(t, this.heap.length - 1);\n    this.siftUp(this.heap.length - 1);\n  }\n\n  /**\n   * Remove an element from the priority queue.\n   * @return The element in the priority queue with the highest priority\n   * (lowest numeric priority value).\n   */\n  dequeue(): T {\n    if (this.empty()) {\n      throw new Error('dequeue called on empty priority queue.');\n    }\n    const t = this.heap[0];\n    this.swap(0, this.heap.length - 1);\n    this.heap.pop();\n    this.siftDown(0);\n    return t;\n  }\n\n  /**\n   * Updates an element at the specified index. This can be a full element\n   * replacement, or it can be an in-place update. The priority is assumed to be\n   * changed, and the internal storage is updated. This function is only useful\n   * if the storage index of the updated element is known; construct the\n   * PriorityQueue with an IndexObserver to track element locations.\n   * @param newT The new element to replace in the priority queue.\n   * @param index The index to insert the new element into.\n   */\n  update(newT: T, index: number) {\n    /* If the element is at the very end of the heap, no sifting is necessary,\n     * it can be safely removed. */\n    const last = (index === this.heap.length - 1);\n    if (!last) {\n      this.swap(index, this.heap.length - 1);\n    }\n    this.heap.pop();\n    if (!last) {\n      /* The element at 'index' has been removed, and replaced with whatever was\n       * at the end of the heap. Since that element might have come from a\n       * different subtree (and not be a direct descendant of the node at\n       * 'index'), we might need to sift this new value up instead of down. Test\n       * both directions, and sift to wherever the node needs to go.\n       */\n      if (this.siftUpIndex(index) !== -1) {\n        this.siftUp(index);\n      } else if (this.siftDownIndex(index) !== -1) {\n        this.siftDown(index);\n      }\n    }\n    this.enqueue(newT);\n  }\n\n  /**\n   * Predicate for testing whether the PriorityQueue is empty.\n   * @return True if the PriorityQueue is empty, otherwise False.\n   */\n  empty(): boolean {\n    return this.heap.length === 0;\n  }\n\n  private onIndexChanged(t: T, newIndex: number) {\n    if (this.indexObserver) {\n      this.indexObserver(t, newIndex);\n    }\n  }\n\n  /*\n   * Standard zero-indexed binary heap array layout:\n   *   Parent(N) = Floor((N - 1) / 2)\n   *   LeftChild(N) = (N * 2) + 1\n   *   RightChild(N) = (N * 2) + 2\n   */\n\n  private getParentIndex(index: number): number {\n    if (index === 0) {\n      return -1;\n    }\n    return Math.floor((index - 1) / 2);\n  }\n\n  private getLeftChildIndex(index: number): number {\n    const candidate = index * 2 + 1;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private getRightChildIndex(index: number): number {\n    const candidate = index * 2 + 2;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private siftUpIndex(index: number): number {\n    const parentIndex = this.getParentIndex(index);\n    if (parentIndex === -1) {\n      return -1;\n    }\n    if (this.compare(parentIndex, index) > 0) {\n      return parentIndex;\n    }\n    return -1;\n  }\n\n  private siftUp(index: number) {\n    let siftIndex = this.siftUpIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftUpIndex(index);\n    }\n  }\n\n  private siftDownIndex(index: number): number {\n    if (index >= this.heap.length) {\n      return -1;\n    }\n    let largestChildIndex = index;\n    const leftChildIndex = this.getLeftChildIndex(index);\n    if ((leftChildIndex !== -1) &&\n        (this.compare(leftChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = leftChildIndex;\n    }\n    const rightChildIndex = this.getRightChildIndex(index);\n    if ((rightChildIndex !== -1) &&\n        (this.compare(rightChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = rightChildIndex;\n    }\n    return (largestChildIndex === index) ? -1 : largestChildIndex;\n  }\n\n  private siftDown(index: number) {\n    let siftIndex = this.siftDownIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftDownIndex(index);\n    }\n  }\n\n  private compare(aIndex: number, bIndex: number): number {\n    return this.comparator(this.heap[aIndex], this.heap[bIndex]);\n  }\n\n  private swap(a: number, b: number) {\n    const temp = this.heap[a];\n    this.heap[a] = this.heap[b];\n    this.heap[b] = temp;\n    this.onIndexChanged(this.heap[a], a);\n    this.onIndexChanged(this.heap[b], b);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Node, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as operation_emitter from './operation_emitter';\nimport {Operation} from './ops/op';\nimport {Optimizer} from './optimizer';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * FeedEntry associates a tensor with user-provided NDArray data.\n */\nexport type FeedEntry = {\n  tensor: Tensor,\n  data: NDArray|InputProvider\n};\n\n/**\n * A FeedDictionary holds a map from tensors to user-provided NDArrays. Feed\n * dictionaries represent the 'entry points' of evaluation, since graph nodes\n * that are replaced by feeds don't need to have their input nodes evaluated.\n * Feed dictionaries usually provide NDArray data for Placeholder nodes, but any\n * node in the graph can be replaced by a feed dictionary entry.\n *\n * @hidden\n */\nexport class FeedDictionary {\n  dict: {[tensorID: number]: FeedEntry} = {};\n\n  /**\n   * Optionally construct a FeedDictionary from an array of entries.\n   * @param feedEntries Optional array of FeedEntry objects.\n   */\n  constructor(feedEntries?: FeedEntry[]) {\n    if (feedEntries) {\n      feedEntries.forEach(entry => this.dict[entry.tensor.id] = entry);\n    }\n  }\n}\n\nexport enum CostReduction {\n  NONE,\n  SUM,\n  MEAN\n}\n\n/**\n * A Session maintains the runtime state required to efficiently evaluate nodes.\n * On their own, graph objects are very lightweight logical topologies; they\n * have no relationship with the GPU. Sessions encapsulate the evaluation of\n * nodes, the management of GPU resources, the caching of evaluation paths, and\n * anything else required to evaluate or train a network.\n */\nexport class Session {\n  /**\n   * @param graph The graph to associate with this Session.\n   * @param math The NDArrayMath interface that this Session should use.\n   */\n  constructor(private graph: Graph, private math: NDArrayMath) {}\n\n  /**\n   * Release all system resources associated with this Session.\n   */\n  dispose() {\n    this.activationArrayMap.dispose();\n    Object.keys(this.runtimeCache).forEach(key => {\n      const runtime = this.runtimeCache[key];\n      if (runtime.operations) {\n        runtime.operations.forEach(op => op.dispose());\n      }\n    });\n    this.runtimeCache = {};\n    if (this.batchSizeScalar != null) {\n      this.batchSizeScalar.dispose();\n    }\n    this.oneScalar.dispose();\n  }\n\n  /**\n   * Evaluate a list of tensors, using the provided feed entries to provide\n   * upstream NDArray input.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param tensors The list of tensors to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed values of the tensors.\n   */\n  evalAll(tensors: Tensor[], feedEntries: FeedEntry[]): NDArray[] {\n    return this.math.scope(() => {\n      const feed = new FeedDictionary(feedEntries);\n      const runtime = this.getOrCreateRuntime(tensors, feed);\n\n      const activations = this.activationArrayMap;\n\n      session_util.disposeAndInitializeOperationOutputs(\n          runtime.nodes, activations);\n      session_util.disposeTransientOperationArrays(\n          runtime.operations, this.activationArrayMap, this.gradientArrayMap);\n\n      session_util.addPersistentArraysToTensorArrayMap(\n          runtime.nodes, activations);\n      session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n          feed, activations, this.math);\n\n      runtime.operations.forEach(op => op.feedForward(this.math, activations));\n\n      const results = tensors.map(x => activations.get(x));\n      tensors.forEach(x => activations.delete(x));\n\n      session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n          feed, activations, this.math);\n\n      return results;\n    });\n  }\n\n  /**\n   * Evaluate a tensor, using the provided feed entries to provide\n   * upstream NDArray input.\n   *\n   * @param tensor The tensor to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed value of the tensor.\n   */\n  eval(tensor: Tensor, feedEntries: FeedEntry[]): NDArray {\n    return this.evalAll([tensor], feedEntries)[0];\n  }\n\n  /**\n   * Trains a batch.\n   * Returns a reduced cost if the costReduction parameter is set.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param costTensor A tensor representing the cost to optimize. Should be a\n   * scalar.\n   * @param feedEntries Feed entries for this train run. Provides inputs.\n   * @param batchSize Batch size for this train loop.\n   * @param optimizer An optimizer to perform weight updates.\n   * @param costReduction An option to allow the user to get a summed, averaged,\n   * or no cost back.\n   * @return The reduced cost, if cost reduction is not NONE. The user is\n   * responsible for disposing the cost NDArray between train loops.\n   */\n  train(\n      costTensor: Tensor, feedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, costReduction = CostReduction.NONE): Scalar {\n    util.assert(\n        util.isScalarShape(costTensor.shape),\n        'Cost tensor for training must be a scalar value.');\n\n    if (this.prevBatchSize !== batchSize) {\n      this.prevBatchSize = batchSize;\n      this.batchSizeScalar = Scalar.new(batchSize);\n    }\n\n    const feed = new FeedDictionary(feedEntries);\n    session_util.throwIfFeedDictionaryContainsNDArrays(feed);\n\n    const runtime = this.getOrCreateRuntime([costTensor], feed);\n    const inferenceOperations = runtime.operations;\n    const backPropOperations = runtime.operations.slice().reverse();\n    const activations = this.activationArrayMap;\n    const gradients = this.gradientArrayMap;\n    gradients.set(costTensor, this.oneScalar);\n\n    session_util.addPersistentArraysToTensorArrayMap(\n        runtime.nodes, activations);\n\n    optimizer.beforeBatch(\n        this.math, batchSize, runtime, activations, gradients);\n\n    return this.math.scope((keep, track) => {\n      let cost = track(Scalar.new(0));\n\n      for (let i = 0; i < batchSize; ++i) {\n        session_util.disposeAndInitializeOperationOutputs(\n            runtime.nodes, activations);\n        session_util.disposeAndInitializeOperationInputGradients(\n            runtime.nodes, gradients);\n        session_util.disposeTransientOperationArrays(\n            runtime.operations, activations, gradients);\n\n        session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n            feed, activations, this.math);\n\n        inferenceOperations.forEach(\n            op => op.feedForward(this.math, activations));\n        backPropOperations.forEach(\n            op => op.backProp(this.math, activations, gradients));\n\n        optimizer.afterExample(this.math, runtime, activations, gradients);\n\n        session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n            feed, activations, this.math);\n\n        cost = this.updateCostForExample(\n            cost, activations.get(costTensor), costReduction);\n      }\n\n      optimizer.afterBatch(\n          this.math, batchSize, runtime, activations, gradients);\n\n      return this.updateCostForBatch(cost, costReduction);\n    });\n  }\n\n  private updateCostForExample(\n      totalCost: Scalar, currCost: Scalar,\n      costReduction: CostReduction): Scalar {\n    if (costReduction === CostReduction.MEAN ||\n        costReduction === CostReduction.SUM) {\n      return this.math.add(totalCost, currCost);\n    }\n    return totalCost;\n  }\n\n  private updateCostForBatch(totalCost: Scalar, costReduction: CostReduction):\n      Scalar {\n    if (costReduction === CostReduction.MEAN) {\n      return this.math.divide(totalCost, this.batchSizeScalar);\n    }\n    return totalCost;\n  }\n\n  private getOrCreateRuntime(tensors: Tensor[], feed: FeedDictionary):\n      SessionRuntime {\n    const key = this.makeRuntimeCacheKey(tensors, feed);\n    let runtime = this.runtimeCache[key];\n    if (runtime === undefined) {\n      let nodes =\n          session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed);\n      // In inference mode split nodes are not needed, but their cost is\n      // negligible, and always adding them in allows for caching of 1 runtime\n      // for both train/eval.\n      nodes = session_util.addSplitNodes(nodes);\n      session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes);\n      session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes);\n      const operations = operation_emitter.emitFromGraphNodes(nodes);\n      runtime = {nodes, operations};\n      this.runtimeCache[key] = runtime;\n    }\n\n    return runtime;\n  }\n\n  private makeRuntimeCacheKey(tensors: Tensor[], feed: FeedDictionary): string {\n    return tensors.map(x => x.id).sort().join('_') + '__' +\n        Object.keys(feed.dict).sort().join('_');\n  }\n\n  /** Maps each output tensor of the graph to its activation value. */\n  activationArrayMap = new TensorArrayMap();\n  /** Maps each tensor of the graph to its derivative wrt the cost function. */\n  gradientArrayMap = new TensorArrayMap();\n  private runtimeCache: {[key: string]: SessionRuntime} = {};\n  /** Batch size of the previous train() call. */\n  private prevBatchSize: number;\n  private batchSizeScalar: Scalar;\n  private oneScalar = Scalar.new(1);\n}\n\n/** @hidden */\nexport type SessionRuntime = {\n  nodes: Node[]; operations: Operation[];\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport {Operation} from './ops/op';\nimport {FeedDictionary} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * Creates an array of graph nodes that stop traversal, based on the contents\n * of the provided FeedDictionary. This is a simple 1:1 extraction of nodes from\n * the FeedDictionary.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to scan for termination nodes.\n * @return an array of Nodes which halt traversal when visited.\n */\nexport function getTerminatingNodesFromFeedDictionary(\n    feedDictionary: FeedDictionary): Node[] {\n  return Object.keys(feedDictionary.dict)\n      .map(tensorID => feedDictionary.dict[+tensorID].tensor.node);\n}\n\n/**\n * Given a tensor and a feed dictionary, computes the set of nodes that need to\n * be evaluated to perform inference.\n *\n * @hidden\n * @param evalTensors The list of tensors to eventually be evaluated.\n * @param feedDictionary The populated feed dictionary.\n * @return The set of nodes to evaluate, in evaluation order.\n */\nexport function getOrderedEvaluationSetFromEvalTensor(\n    evalTensors: Tensor[], feedDictionary: FeedDictionary): Node[] {\n  const terminatingNodes =\n      getTerminatingNodesFromFeedDictionary(feedDictionary);\n  const evalNodes = evalTensors.map(x => x.node);\n  const unorderedEvaluationSet =\n      graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes);\n  const orderedEvaluationSet =\n      graph_util.getOrderedEvaluationSet(unorderedEvaluationSet);\n  return orderedEvaluationSet;\n}\n\n/**\n * Traverses the provided node array and adds all persistent node NDArrays to\n * the provided TensorArrayMap.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n * @param tensorArrayMap The map that receives the NDArrays from persistent\n * nodes.\n */\nexport function addPersistentArraysToTensorArrayMap(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode || node instanceof ConstantNode) {\n      tensorArrayMap.set(node.output, node.data);\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function getVariableNodesFromEvaluationSet(evaluationSet: Node[]):\n    VariableNode[] {\n  const nodes: VariableNode[] = [];\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode) {\n      nodes.push(node);\n    }\n  });\n  return nodes;\n}\n\n/**\n * @hidden\n */\nexport function throwIfFeedDictionaryContainsNDArrays(\n    feedDictionary: FeedDictionary) {\n  Object.keys(feedDictionary.dict).forEach(tensorID => {\n    if (feedDictionary.dict[+tensorID].data instanceof NDArray) {\n      throw new Error(\n          'training requires FeedDictionary entries to be InputProviders' +\n          'and not NDArrays.');\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function loadInputsFromFeedDictionaryToTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    let data: NDArray;\n    if (feedEntry.data instanceof NDArray) {\n      data = feedEntry.data as NDArray;\n    } else {\n      const provider = feedEntry.data as InputProvider;\n      data = provider.getNextCopy(math);\n    }\n\n    util.assert(\n        util.arraysEqual(feedEntry.tensor.shape, data.shape),\n        `Error loading FeedEntry: feeding NDArray of shape ${data.shape} ` +\n            `does not match Tensor (id: ${feedEntry.tensor.id}) shape: ` +\n            `${feedEntry.tensor.shape}.`);\n    activations.set(feedEntry.tensor, data);\n  });\n}\n\n\n/**\n * @hidden\n */\nexport function releaseFeedDictionaryInputsFromTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    if (!(feedEntry.data instanceof NDArray)) {\n      const provider = feedEntry.data as InputProvider;\n\n      const feedEntryArray = activations.get(feedEntry.tensor);\n      provider.disposeCopy(math, feedEntryArray);\n    }\n\n    activations.delete(feedEntry.tensor);\n  });\n}\n\n/**\n * Removes all nodes from the provided Node array whose output tensors exist in\n * the provided feed dictionary. After calling this, the Node array should\n * contain zero Placeholder nodes, or the user has failed to provide a feed for\n * a Placeholder node.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to process.\n * @param evaluationSet The array of nodes to remove input nodes from.\n */\nexport function removeFeedDictionaryNodesFromEvaluationSet(\n    feedDictionary: FeedDictionary, evaluationSet: Node[]) {\n  let i = 0;\n  while (i < evaluationSet.length) {\n    const node = evaluationSet[i];\n    if (feedDictionary.dict[node.output.id] != null) {\n      evaluationSet.splice(i, 1);\n    } else {\n      ++i;\n    }\n  }\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from operation outputs and sets\n * the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param tensorArrayMap The map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationOutputs(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (!graph_util.isInputNode(node)) {\n      if (!graph_util.isPassthroughNode(node, tensorArrayMap)) {\n        tensorArrayMap.disposeArray(node.output);\n      }\n      tensorArrayMap.set(node.output, null);\n    }\n  });\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from derivatives of operation\n * inputs and sets the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param gradients The gradient map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationInputGradients(\n    evaluationSet: Node[], gradients: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    Object.keys(node.inputs).forEach(inputName => {\n      const input = node.inputs[inputName];\n      if (gradients.get(input, true) !== gradients.get(node.output, true)) {\n        gradients.disposeArray(input);\n      }\n      gradients.set(input, null);\n    });\n  });\n}\n\n\n/**\n * Calls underlying operation disposeTransientArrays methods which clean up any\n * NDArrays which operations may have created during a run.\n *\n * @hidden\n * @param operationNodes The array of Nodes to traverse.\n * @param outputTensor The tensor being evaluated.\n * @param map The TensorArrayMap to operate on.\n */\nexport function disposeTransientOperationArrays(\n    operations: Operation[], activations: TensorArrayMap,\n    gradients: TensorArrayMap) {\n  operations.forEach(op => op.disposeTransientArrays(activations, gradients));\n}\n\n/**\n * Iterates the provided Node array and throws an exception if there are any\n * Placeholder nodes present. Call after the evaluation set has been pruned with\n * the accompanying FeedDictionary to ensure that all inputs have been resolved.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n */\nexport function throwErrorIfEvaluationSetContainsPlaceholderNodes(\n    evaluationSet: Node[]) {\n  evaluationSet.forEach(node => {\n    if (node instanceof PlaceholderNode) {\n      const shape = '[' + node.output.shape.join(', ') + ']';\n      throw new Error(\n          'Placeholder node \"' + node.name + '\" ' + shape +\n          ' not present in feed dictionary.');\n    }\n  });\n}\n\n/**\n * Injects splits nodes after every node that has multiple consumers.\n *\n * @hidden\n * @param nodes The node list in evaluation order.\n * @return The node list with split nodes injected.\n */\nexport function addSplitNodes(nodes: Node[]): Node[] {\n  const nodeIdToNumConsumers: number[] = [];\n  const nodeIdToSplitNode: {[nodeId: number]: SplitNode} = {};\n\n  // Find nodes that have multiple consumers.\n  nodes.forEach(node => {\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const input = inputTensor.node;\n      if (nodeIdToNumConsumers[input.id] == null) {\n        nodeIdToNumConsumers[input.id] = 0;\n      }\n      nodeIdToNumConsumers[input.id]++;\n      if (nodeIdToNumConsumers[input.id] > 1 &&\n          nodeIdToSplitNode[input.id] == null) {\n        nodeIdToSplitNode[input.id] = new SplitNode(input.graph, inputTensor);\n      }\n    });\n  });\n\n  // Inject a split node after each node that has multiple consumers and\n  // rewire the inputs of the consumers to consume the output tensors of the\n  // split node instead of the original node. Each consumer consumes a\n  // different output tensor so that derivatives are not overwritten.\n  // x-->y  becomes x-->s-->y   where y consumes the 1st output tensor of s\n  // |-->z              |-->z     and z consumes the 2nd output tensor of s\n  const newNodes: Node[] = [];\n  nodes.forEach(node => {\n    newNodes.push(node);\n    if (node.id in nodeIdToSplitNode) {\n      const splitNode = nodeIdToSplitNode[node.id];\n      newNodes.push(splitNode);\n    }\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const inputId = inputTensor.node.id;\n      if (inputId in nodeIdToSplitNode) {\n        node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor();\n      }\n    });\n  });\n  return newNodes;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {SessionRuntime} from './session';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport class SGDOptimizer extends Optimizer {\n  constructor(private learningRate: number, specifiedVariableList?: Node[]) {\n    super(specifiedVariableList);\n  }\n\n  beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    this.variableNodes = this.specifiedVariableNodes == null ?\n        session_util.getVariableNodesFromEvaluationSet(runtime.nodes) :\n        this.specifiedVariableNodes;\n    if (batchSize !== this.prevBatchSize) {\n      this.prevBatchSize = batchSize;\n      this.c = Scalar.new(-this.learningRate / batchSize);\n    }\n    this.variableNodes.forEach(\n        node => this.variableGradients.set(\n            node.output, NDArray.zeros(node.output.shape)));\n  }\n\n  afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const gradient = gradientArrayMap.get(node.output);\n        const accumulatedGradient = this.variableGradients.get(node.output);\n        this.variableGradients.set(\n            node.output, keep(math.add(gradient, accumulatedGradient)));\n        accumulatedGradient.dispose();\n      });\n    });\n  }\n\n  afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const oldVariable = activationArrayMap.get(node.output);\n        const gradient = this.variableGradients.get(node.output);\n        const variable =\n            math.scaledArrayAdd(this.c!, gradient, this.one!, oldVariable);\n        activationArrayMap.set(node.output, keep(variable));\n        node.data = variable;\n\n        oldVariable.dispose();\n      });\n    });\n\n    this.variableGradients.dispose();\n    this.variableGradients = new TensorArrayMap();\n  }\n\n  dispose() {\n    if (this.c != null) {\n      this.c.dispose();\n    }\n    this.one.dispose();\n  }\n\n  setLearningRate(learningRate: number) {\n    this.learningRate = learningRate;\n  }\n\n  private variableGradients = new TensorArrayMap();\n  private prevBatchSize: number;\n  private one = Scalar.new(1);\n  private c: Scalar;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from './graph';\nimport {NDArray} from './math/ndarray';\n\n/**\n * TensorArrayMap is an internal map from Tensor IDs to NDArrays. Since NDArrays\n * can be backed by WebGL textures, the TensorArrayMap is only used inside of a\n * Session.\n */\nexport class TensorArrayMap {\n  /**\n   * Add or replace an entry in the map.\n   * @param tensor The tensor key.\n   * @param array The NDArray value, can be null.\n   */\n  set(tensor: Tensor, array: NDArray|null) {\n    this.dict[tensor.id] = array;\n  }\n\n  /**\n   * Returns the NDArray associated with the provided tensor. Will throw an\n   * exception if the tensor is not a key in the map, or if the associated\n   * NDArray is null.\n   * @param tensor The tensor key.\n   * @param skipChecks False by default. If true will skip all checks.\n   * @return The NDArray associated with the tensor.\n   */\n  get(tensor: Tensor, skipChecks = false): NDArray {\n    if (!skipChecks && this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    const nda = this.dict[tensor.id];\n    if (!skipChecks && nda === null) {\n      throw new Error('tensor ' + tensor.id + ' has null array.');\n    }\n    return nda!;\n  }\n\n  /**\n   * Removes a tensor/NDArray pair from the map.\n   * @param tensor The tensor key.\n   */\n  delete(tensor: Tensor) {\n    delete this.dict[tensor.id];\n  }\n\n  disposeArray(tensor: Tensor) {\n    if (this.dict[tensor.id] === undefined) {\n      return;\n    }\n    const nda = this.dict[tensor.id];\n    if (nda === null) {\n      return;\n    }\n    nda.dispose();\n    this.dict[tensor.id] = null;\n  }\n\n  /**\n   * @return The number of tensor/NDArray pairs in the map.\n   */\n  size(): number {\n    return Object.keys(this.dict).length;\n  }\n\n  /**\n   * Iterate over all contained NDArray values and dispose them.\n   */\n  dispose() {\n    Object.keys(this.dict).forEach(tensorID => {\n      const nda = this.dict[+tensorID];\n      if (nda) {\n        nda.dispose();\n      }\n    });\n    this.dict = {};\n  }\n\n  /**\n   * Tests to see if a tensor has a null associated with it. Throws\n   * if the tensor is not a key in the map.\n   * @param tensor The tensor key.\n   * @return True if the associated NDArray is null, else False.\n   */\n  hasNullArray(tensor: Tensor): boolean {\n    if (this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    return this.dict[tensor.id] === null;\n  }\n\n  private dict: {[tensorID: number]: NDArray | null} = {};\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport type Vector = number[] | Float64Array | Float32Array | Int32Array |\n    Int8Array | Int16Array;\n\n/** Shuffles the array using Fisher-Yates algorithm. */\n// tslint:disable-next-line:no-any\nexport function shuffle(array: any[]|Uint32Array|Int32Array|\n                        Float32Array): void {\n  let counter = array.length;\n  let temp = 0;\n  let index = 0;\n  // While there are elements in the array\n  while (counter > 0) {\n    // Pick a random index\n    index = (Math.random() * counter) | 0;\n    // Decrease counter by 1\n    counter--;\n    // And swap the last element with it\n    temp = array[counter];\n    array[counter] = array[index];\n    array[index] = temp;\n  }\n}\n\n/** Clamps a value to a specified range. */\nexport function clamp(min: number, x: number, max: number): number {\n  return Math.max(min, Math.min(x, max));\n}\n\n/** Returns a sample from a uniform [a, b] distribution. */\nexport function randUniform(a: number, b: number) {\n  return Math.random() * (b - a) + a;\n}\n\n/**\n * Samples from a gaussian distribution.\n *\n * @param mean The mean. Default is 0.\n * @param stdDev The standard deviation. Default is 1.\n */\nexport function randGauss(mean = 0, stdDev = 1, truncated = false): number {\n  let v1: number, v2: number, s: number;\n  do {\n    v1 = 2 * Math.random() - 1;\n    v2 = 2 * Math.random() - 1;\n    s = v1 * v1 + v2 * v2;\n  } while (s > 1);\n\n  const result = Math.sqrt(-2 * Math.log(s) / s) * v1;\n  if (truncated && result > 2) {\n    return randGauss(mean, stdDev, true);\n  }\n  return mean + stdDev * result;\n}\n\n/** Returns squared eucledian distance between two vectors. */\nexport function distSquared(a: Vector, b: Vector): number {\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    const diff = a[i] - b[i];\n    result += diff * diff;\n  }\n  return result;\n}\n\nexport function assert(expr: boolean, msg: string) {\n  if (!expr) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertShapesMatch(\n    shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void {\n  assert(\n      arraysEqual(shapeA, shapeB),\n      errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`);\n}\n\n// tslint:disable-next-line:no-any\nexport function flatten(arr: any[], ret?: number[]): number[] {\n  ret = (ret === undefined ? [] : ret);\n  for (let i = 0; i < arr.length; ++i) {\n    if (Array.isArray(arr[i])) {\n      flatten(arr[i], ret);\n    } else {\n      ret.push(arr[i]);\n    }\n  }\n  return ret;\n}\n\nexport type ArrayData = number|number[]|number[][]|number[][][]|number[][][][];\n\nexport function inferShape(arr: ArrayData): number[] {\n  const shape: number[] = [];\n  while (arr instanceof Array) {\n    shape.push(arr.length);\n    arr = arr[0];\n  }\n  return shape;\n}\n\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\n\nexport function isScalarShape(shape: number[]): boolean {\n  return shape.length === 0;\n}\n\n// tslint:disable-next-line:no-any\nexport function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) {\n  if (n1.length !== n2.length) {\n    return false;\n  }\n  for (let i = 0; i < n1.length; i++) {\n    if (n1[i] !== n2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\n\nexport function tanh(x: number): number {\n  // tslint:disable-next-line:no-any\n  if ((Math as any).tanh != null) {\n    // tslint:disable-next-line:no-any\n    return (Math as any).tanh(x);\n  }\n  if (x === Infinity) {\n    return 1;\n  } else if (x === -Infinity) {\n    return -1;\n  } else {\n    const e2x = Math.exp(2 * x);\n    return (e2x - 1) / (e2x + 1);\n  }\n}\n\nexport function sizeToSquarishShape(size: number): [number, number] {\n  for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) {\n    if (size % a === 0) {\n      return [a, size / a];\n    }\n  }\n  return [1, size];\n}\n\nexport function createShuffledIndices(n: number): Uint32Array {\n  const shuffledIndices = new Uint32Array(n);\n  for (let i = 0; i < n; ++i) {\n    shuffledIndices[i] = i;\n  }\n  shuffle(shuffledIndices);\n  return shuffledIndices;\n}\n"]} diff --git a/demos/imagenet/imagenet-demo.html b/demos/imagenet/imagenet-demo.html new file mode 100644 index 0000000000..77b7029bb4 --- /dev/null +++ b/demos/imagenet/imagenet-demo.html @@ -0,0 +1,49 @@ + + + + + + + + + + LearnJS Imagenet Demo + + + + + + + + + + diff --git a/demos/imagenet/imagenet-demo.ts b/demos/imagenet/imagenet-demo.ts new file mode 100644 index 0000000000..57d59bca03 --- /dev/null +++ b/demos/imagenet/imagenet-demo.ts @@ -0,0 +1,220 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import '../demo-header'; +import '../demo-footer'; +import {Array3D, gpgpu_util, GPGPUContext, NDArray, NDArrayMathCPU, NDArrayMathGPU} from '../deeplearnjs'; +import * as imagenet_classes from '../models/imagenet_classes'; +import * as imagenet_util from '../models/imagenet_util'; +import {SqueezeNet} from '../models/squeezenet'; +// tslint:disable-next-line:no-unused-variable +import {PolymerElement, PolymerHTMLElement} from '../polymer-spec'; + +// tslint:disable-next-line:variable-name +export const ImagenetDemoPolymer = PolymerElement({ + is: 'imagenet-demo', + properties: { + layerNames: Array, + selectedLayerName: String, + inputNames: Array, + selectedInputName: String + } +}); + +/** + * NOTE: To use the webcam without SSL, use the chrome flag: + * --unsafely-treat-insecure-origin-as-secure=\ + * http://localhost:5432 + */ + +const NUM_CLASSES = 1000; +const IMAGE_SIZE = 227; +const TOP_K_CLASSES = 5; + +const INPUT_NAMES = ['cat', 'dog1', 'dog2', 'beerbottle', 'piano', 'saxophone']; +export class ImagenetDemo extends ImagenetDemoPolymer { + private variables: {[varName: string]: NDArray}; + + private math: NDArrayMathGPU; + private mathCPU: NDArrayMathCPU; + private gl: WebGLRenderingContext; + private gpgpu: GPGPUContext; + private renderGrayscaleChannelsCollageShader: WebGLShader; + + private squeezeNet: SqueezeNet; + + private webcamVideoElement: HTMLVideoElement; + private staticImgElement: HTMLImageElement; + + private layerNames: string[]; + private selectedLayerName: string; + private inputNames: string[]; + private selectedInputName: string; + + private inferenceCanvas: HTMLCanvasElement; + + ready() { + this.inferenceCanvas = + this.querySelector('#inference-canvas') as HTMLCanvasElement; + this.staticImgElement = + this.querySelector('#staticImg') as HTMLImageElement; + this.webcamVideoElement = + this.querySelector('#webcamVideo') as HTMLVideoElement; + + this.layerNames = []; + this.selectedLayerName = 'conv_1'; + + const inputDropdown = this.querySelector('#input-dropdown')!; + // tslint:disable-next-line:no-any + inputDropdown.addEventListener('iron-activate', (event: any) => { + const selectedInputName = event.detail.selected; + if (selectedInputName === 'webcam') { + this.webcamVideoElement.style.display = ''; + this.staticImgElement.style.display = 'none'; + } else { + this.webcamVideoElement.style.display = 'none'; + this.staticImgElement.style.display = ''; + } + this.staticImgElement.src = 'images/' + event.detail.selected + '.jpg'; + }); + + if (navigator.getUserMedia) { + navigator.getUserMedia( + {video: true}, + (stream) => { + this.webcamVideoElement.src = window.URL.createObjectURL(stream); + this.initWithWebcam(); + }, + (error) => { + console.log(error); + this.initWithoutWebcam(); + }); + } else { + this.initWithoutWebcam(); + } + + this.gl = gpgpu_util.createWebGLContext(this.inferenceCanvas); + this.gpgpu = new GPGPUContext(this.gl); + this.math = new NDArrayMathGPU(this.gpgpu); + this.mathCPU = new NDArrayMathCPU(); + + this.squeezeNet = new SqueezeNet(this.gpgpu, this.math); + this.squeezeNet.loadVariables().then(() => { + requestAnimationFrame(() => this.animate()); + }); + + this.renderGrayscaleChannelsCollageShader = + imagenet_util.getRenderGrayscaleChannelsCollageShader(this.gpgpu); + } + + private initWithoutWebcam() { + this.inputNames = INPUT_NAMES; + this.selectedInputName = 'cat'; + this.staticImgElement.src = 'images/cat.jpg'; + this.webcamVideoElement.style.display = 'none'; + this.staticImgElement.style.display = ''; + + if (location.protocol !== 'https:') { + (this.querySelector('#ssl-message') as HTMLElement).style.display = + 'block'; + } + + (this.querySelector('#webcam-message') as HTMLElement).style.display = + 'block'; + } + + private initWithWebcam() { + const inputNames = INPUT_NAMES.slice(); + inputNames.unshift('webcam'); + this.inputNames = inputNames; + this.selectedInputName = 'webcam'; + } + + private animate() { + const startTime = performance.now(); + + const isWebcam = this.selectedInputName === 'webcam'; + + const canvasTextureShape: [number, number] = [IMAGE_SIZE, IMAGE_SIZE]; + const canvasTexture = + this.math.getTextureManager().acquireTexture(canvasTextureShape); + + const element = isWebcam ? this.webcamVideoElement : this.staticImgElement; + this.gpgpu.uploadPixelDataToTexture(canvasTexture, element); + + this.math.scope((keep, track) => { + const preprocessedInput = + track(this.squeezeNet.preprocessColorTextureToArray3D( + canvasTexture, canvasTextureShape)); + + const inferenceResult = this.squeezeNet.infer(preprocessedInput); + const namedActivations = inferenceResult.namedActivations; + + this.layerNames = Object.keys(namedActivations); + this.layerNames.forEach(layerName => track(namedActivations[layerName])); + + const topClassesToProbability = + this.squeezeNet.getTopKClasses(inferenceResult.logits, TOP_K_CLASSES); + + let count = 0; + for (const className in topClassesToProbability) { + if (!(className in topClassesToProbability)) { + continue; + } + document.getElementById('class' + count)!.innerHTML = className; + document.getElementById('prob' + count)!.innerHTML = + '' + Math.floor(1000 * topClassesToProbability[className]) / 1000; + count++; + } + + const endTime = performance.now(); + + (this.querySelector('#totalTime') as HTMLDivElement).innerHTML = + 'last inference time: ' + + Math.floor(1000 * (endTime - startTime)) / 1000 + 'ms'; + + // Render activations. + const activationNDArray = namedActivations[this.selectedLayerName]; + + // Compute max and min per channel for normalization. + const maxValues = this.math.maxPool( + activationNDArray, activationNDArray.shape[1], + activationNDArray.shape[1], 0); + const minValues = this.math.minPool( + activationNDArray, activationNDArray.shape[1], + activationNDArray.shape[1], 0); + + // Logically resize the rendering canvas. The displayed width is fixed. + const imagesPerRow = Math.ceil(Math.sqrt(activationNDArray.shape[2])); + const numRows = Math.ceil(activationNDArray.shape[2] / imagesPerRow); + this.inferenceCanvas.width = imagesPerRow * activationNDArray.shape[0]; + this.inferenceCanvas.height = numRows * activationNDArray.shape[0]; + + imagenet_util.renderGrayscaleChannelsCollage( + this.gpgpu, this.renderGrayscaleChannelsCollageShader, + activationNDArray.getTexture(), minValues.getTexture(), + maxValues.getTexture(), activationNDArray.getTextureShapeRC(), + activationNDArray.shape[0], activationNDArray.shape[2], + this.inferenceCanvas.width, numRows); + }); + + this.math.getTextureManager().releaseTexture( + canvasTexture, canvasTextureShape); + + requestAnimationFrame(() => this.animate()); + } +} + +document.registerElement(ImagenetDemo.prototype.is, ImagenetDemo); diff --git a/demos/imagenet/imagenet.html b/demos/imagenet/imagenet.html new file mode 100644 index 0000000000..9e9edc623e --- /dev/null +++ b/demos/imagenet/imagenet.html @@ -0,0 +1,114 @@ + + + + + + + + + + diff --git a/demos/imagenet/images/beerbottle.jpg b/demos/imagenet/images/beerbottle.jpg new file mode 100644 index 0000000000000000000000000000000000000000..08e64feaa3e731e3b62660af6ddf390137e259f7 GIT binary patch literal 4257 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 F{Xe|m%K-oY literal 0 HcmV?d00001 diff --git a/demos/imagenet/images/cat.jpg b/demos/imagenet/images/cat.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b506747111f9c7d35851aa8b3f1eb437b03a1358 GIT binary patch literal 24557 zcmb??2Q*x5x9}OG_a42C-g_BDFQfM^!HhC`??e!Z-U&hUPC}HBM2JqJccP0fh!Q0H zllQ&f_kMS+yY5>5T6fP{&+N0G-JkuOv!7$!&E2g6#2TtFRR9D601)Z}+#LeydQKj` z9zISUo=hVAf`FtVOdA~?_ya_AAPWFY%ce$$1^{TN&tG$Ff6Wp9T4RhIXdMg`5VaG< zG7H$hTLY+60+9{?0E2M@*nctoJ>0G1{e&qgJ=8PMRfTD({AC<(=g%BUE#T(v>usQ> z$Yf@2!GtvrfB{;70$>FgZQ(wif6M>35#{s0;9}-a1OPC}_h;n#DZBjY)VMxS@p^M8 zN{ZkQ?SBDcguM?Ol>}uJPmmqTI12AX;pBEk21+P=3IMS25pD zoKKifh{?{?7Vg621GjbkqxJt9{;bvCI#~-*WrFgpWfbn`?f*9o{m&N$fC~@-&ug5m?kDkYebof1arN|{XANI64!eUJX0!ae(YvG?llP29VrqNS3jvZsopdPOx& zbxqAgtwQZWol4zG{gnothMPv8CV-}ZrkCb`mYi0a7ET*S+eo`WhepRuXFwN1S3>uh z?wp>1UX9+9K8L=W{(ym!L7u^xA%mfVVV9AN@jfGxF@y0V;~oM3y1<6RCduZ+md)1B zcFE4cZp!|Yy_J23gNg&j5zJA;vBXKhDaYx>SaDtaq6 zD_$x=mBN%dmBGqt%5lmgDx@mLD!D4lsw}FGsx_*|YGP_3YMtsB>YD1Q>a#F<7#vmw zJJyiU2-E1%#Md;`%+*}i;@0xkYS%{7*3eGZUeaOHao1_p1$1G$>AGL_IP|>q-sxlN z>*>GH|7IX$5NgnGNM`uZu-fp#NYN8hE4S(w?d zIgL5e{H+C+g^5ME#kr-5Wv1npm6%nG)r>WVb)fa&1DXe}4?a93dT9IbjSYs4sZF)b zFI!#PV%u{&m|dRTF^zB%blyK>nk^GHygJ$cT#s3_Z|-hk3f%cPae-0&s8s|SEkpox2AWw z56H*b=dCX}>H+iFkJImo-C0#6&ydeXVnt$eVsGORaYONf@mcY|65t6#i9(6b6Yr87l17rnlM7NX zQ`}Q#Qsq)B(@4^S(>Btz(_1o_GU77MG9P9RW{GCK%*M_3%U*r1_55uPYfeheuUx0x z=@*JGUggo{#pYe+Bl0H-``74MnfzxY7$ zA-My$Bf8`6WAMlGPS4JRF2}BoPY*vWcAIri_2~DE^lJ7F^r`lB_bc>&9FQG&KL{Oc z8<`MCcmQjh(w_{Rc?c*}z9TRdBU6aa_eN(Wh;c1=e@fqWp zxml~()j7o6&b;gV$%6mF&0@q7#!}o@;;&iDbj!snTr00u#aBP9DX)EAH(X!bfN$(? z`fUE%ivC9MEo+-`yJ|;x=l!ng?%1B?-qyb7{>?$mA<1Fh5$93Uclqz1kIjy^PP|X< zP7{7m|EM?W!ap>W8NI(v{oS|yh5tu?`QO|?`$rB;2>@UbRQFo?56z<(03^>*^b{YYBhw#A zB?BX-|HuQMfxUyhx4k6q0MgwN6~8+I>5KGmXF|IF>E8ZH(|@!4e{k`Spa1mC zzV?Brz7pl9hi8yC($UG63Fhu=@9l2;$0J+UzgEZlkB>ec-o8jbH(n-TK|v`1@Np0k z{>vp0zA~!KTe-XY!43de836D*`R?wf=y58TTcNYenA01MlKMw`Y!gqOm_B;NOxJ5@9#dcFd-4LET&@Gg4&)+_D)Fk zU~hZFU>zfPunSxY!6J8`NhS~)=;rBW?`z8x=;rF~0}YgA`Aazzh5sQ7urU3_;_D*I zqVUHmlbN<2Di&{hCNX|-KDdyGB$I>`zmS-eq_F6pz=XsF1f>LoMEL}Tpn_6RK_RC9 z0v41tZ-fKXKw0&_Y@x1XS^g`ifPeu001<_rHt&VMKWY)kW0>5>*Sz9&kT5dv{-$vMh_Zl7ytV zxU!;>lDLw%h?s<`u&RWVih`)Bh`5A;xTMOzWdBnJrHvnfL_j4ZMIFqqISw3dw*n+|Humcud+}jZ+lx`4{sw657&RK z{6D8#tv^-n?cw3ZB+f6%#HnoyN4ozx_;USOqQ4_nw)aN*+apxHQA~g37>fKKe1VJG zBP4_o!h8}45qmySgro?cq^*=VpC}6K#T>*XMC=_{{!1S5AG!OxMo|=0Jf8nLbVF^0 zq=Y2wq=fi{g+(3sgoGq)`D_tzJ3hFul!PE$9F-#nTNVM7ivoYj=0D2lUnEp*{z3n} zDNq;x-d6VRsJ-Nk+BA2IfD(WKMn^{nW1t2M3=B*xd~DRQ0gDI^4+o!wh?JCsh=hcU zlI|WEISmB~2^BLH4Lv<0BO}>87FHGpRyqbohCfO`C{Zj-EJAE-LI!dYa)$qJxa$N+ zuz?L=0}LVo&`3aF63|@_K##hgqJdFIx_{s9Ffh@vKxkk98wWKlM+~5Wz+g0#>nOkk zqfY2(U~~);fRq_ih>S%+AB)`9OIY!7Dg~sd!N9I-9Gg|-m{Q3*a_!`vm?2654G8$7 z{@>bB2pEKhj)94q6GHic0uUGtl_2n6JRmd@Ff*x;0y>L6nJtE}SL!kO<08d|t~CnC z$@tv@fRAEBv5)|Az;)8BF>(7e|4CDe+N@?6rFFE6GlYb=UO2>=tVPp8tO&hm!;tN@ zuJRmlq_?PoK0!Vr-gBd)b~+`WuBGuKQIE;((^ z;rwjbe-J}{3WUv5LPzLRg=R$T)$t(wIzn0jL*`T{Tu_n*c)|t^UBpj|^ApE>qoVtj z_GL%BjeogXjdnB9ujYf2Sv7e(?!YhVTB%er&K}BS+?>kV>wW$1QkPTg=p5znEL{Hr zh3Nx=%3o^P_;0(WsX2n5$L4$DOo947Xs8VI`Q}A2DMxiw3Z~`*ys_|Su2zxroAfd& zq)ZjhSq4AMfeWso91TNX_;$3+#N16j8x4Q;&1J6sEN;?Wc<(%}O8)${C;d4%2i2-@e3Z>Q3{MQaWV zqvUv{on8x075Y;_c?nY|iD8;dHBn=)=jG3;~Ej8#Cix&j)D-vPy?2uY2))&guD~I2!4oSvF?b%d6396Mx6U3B2(+Fz{@$&)i6lZGow=@xgMowsa zBP}tr%IB>#l}O~|2@GNrhBftDj5Ig0W#@VC;Dj>IJ$*BQ1e5WA(i%@;xLWtd3bN}q zw^l?kIG#_&;ORF7&k|EkN3cA@;@KEh%MMstHA1LWo_cX4qNGg<*P^CIhATdSS~l37#_V#Elmr!Ld|_%_lYr~eUSJfl`a{M z*(Ai7im-)|6d3(rJgid2JTwlMxfwc~N@0BRW>KE>o;)o*;2pjYqai4UUNDBCeKHY{ z_5)sM`i9b#-@oBBjqScZb+D$VSrOV#%-x_t@_ zX>n*U{E>2~Vb+Qv{fjydRRd$@w#t6lhzz1fCq%O=mdC;Gran{uW(z5_;x^6@P8m{F zz+y@c^AMtS0xtj;5h8^|j`BeJyDF|)@~VuhxZP8(DkYnNFqmAXTGbt34Uwx%qPV1u zCvSu*x)HEh549b&=0uAYxg0emK&BJ7Sn$i1x-NodPL_OOj z|EUz89H)R^!*1Ia%Ea#Ota`5#*n|2CN!Z6XZ94Pl&8Q~TJ1hGlaiac8V3-o?tRB{z zLf)!y*_yhI3O1ZAM3v&)LFiM)6|3(SKZkgCZ)w`R6^-k+(b6dt0Ip8Cb-BwGef_lY z5>}d>{h;EKHvPA0!i55~3M10HhW(Z*JSbe|be&KTy3%v)s4AfK7xan!U z=3ndVN53JOR39!7v^a2=F?exk7R7Zj~V`$CzauY?!QUyv8y$W}kc22aZkt58xlh%&X$4N75B{TqQJFp^8x6)GdcvKIo z2`D*npWx3YGiC8IRJa4AK-Yyo1oq0FuF!nhJE>ZKDP}y7+cs zPp|JU;k9NZHCjj7zhdexEA3iqB#jJ&);L!n;oVV}Qj>^DRU8gG#~zxDn!vrCC^kh$ zuLa8Kx#*x&VFxBD4)q2G-^89IJ2aQN}{PUEnIMO7dB}QwcPNgQt+^b6}m(9dwjYc1j9D z==s#s^rY1*rLf0SZ9CB|5~}^{r2TSG6D=Z9RA6@CI4s|QY`=z?GWE#bcfs|*R3m@0L3on+IPJO=T5%|232sm~BlzH!vz+RN8a{`*T z$+Jy$O;)bx3}w;tKxni-|JJ6;^)c@!NWXNc@S1FJ+S}+|u;}_*Ww)O$4BSV_dPCFC zpTUkm0?DoL{z;u*(%u7ifD*^L$0^%Pzt(=GcS0iS?xfIC8ijSd2k5qo@9idEjWiA( zj58#Bk|{BOv4IxEoH;vtw|o$60R-33Du(J>G4@s(B# zK)x~rfJZ*y{IwaM&>}*%5IZ}U+564RqWL^!eXcs5fG54iX83jO#t^?8TM@so!O#1u zd$bw*@WLbu1d{4w0&Ya_;|1NFq4`<7$(FP?la6bHCt!1aQ|HCUWmf}Lbtx6UMmF^h z-!T(zoR5MRS1i0?BCHeYiBl3+)g{3$zPirOv~Zj1(gh7OHj~-0f6ezP5G*PS@wB!$ z6sVp(iCchGBMX9ha$p58xQ!9+6T>W?J!)!8FogRyN>`^{4<%j0?pZ0Gmp&f1Nz zIkiv9rrlqgpWEay2z^2$@=0_un0S>M8qjFmvee492W`*UE({KaRg-Mh-}Dk-}*RE3r}w+Js0J!@HqRjL;zB8UfAlk|kzG60IV5UjKy{Ps}^x5T*8ryXgz znpRbuF_~$MTLYsESg}8~!u6L3&7U)h5EBa32HEA5(B(Ml>8kj&$XfH?0i;xTxyVP9 z3Q|00rv;$j%`d$~`%HR8La=SqxJ#4F=>u3F#wK}V-;Y1?vr00s5bx@fu-`sjPBXg$ z5@w+(nZ_T724tS-5z2Pjb)U^z9v|qCHHc6c(rEcPk!!84A@-gY)9!sN-|0a#P|K1IpEIYdim zNEDWY2(-2mS)Oj^CpjY>XM)d;7H zNY1P5TY&@e84C@~uZ>*j*)%y?V@0%~u3Wq&Z~2z45svTZ)`w%&SX>6*5F)+Sf02iM z*kf+#l|P}{n@i3+=k7T&g3ql2QU|d6xhgy#!DZsp_?aSON{$xUv9!UC+#T!_LZkOT z8ich?+7c>SR=gJLtEalgtUlM~F@E%g%HB@ZnATJOaef)j=?zxbC{=+N>$7*-`LA|y z)h6_3genT0X|6p3A@E6ldB%)4jgNQJmVA0tZk=x)wK=rk-T?;!XPt?MWCooNxZ@V< zI`WH6?H^%}n5Rfe8omYJ0ZrGb<=T@U-*8d9nrp6McIsd^vT%Z{lLj;My5Mv^ljQ9I z&26ITy6e84aeb88A|5sd?Fw)C668#j6U4n?h&xQjVON~V45J1(`#+ZZ^wr3?)hPFA z>>vv(>x;6u<5-ZM20``i*<^c{X=_&(hfQ)x zvnE6aB>jp|I0$iWD1F<}Hw~A$I-!`FqNiF&GIz4_Ad*YPK(em2#c%5IS|R?n zJoVX_Lg_ZK&;<>n!lo|W$Nk#MG1xLAH;lzM7`QzcYtIa4)g^sj-|7Gnx8q&{e=eoEV9foENj5FNl;RRyFi_$ zE?b#4b3Jke52g>TWXKtu@V5Cr+rA?Yzt~ zyaP^@ri4b7T%rSAZAi5UCGcA?J?}@{UgtPoPm%PV9Tf4OPArmgJ0_u?k}>PKGEHx! zHajNge3Eo4cB@SJeiHCens$djuiFc0_Ruobvpm#>7nfJ1m3|ATKDmVBJ<;n>N*}}m z7`9ax-Zt7FPI5eeLSro1{A4HMBoC*>_`oKH5zj{Hx{L-sW{4;Y&dYcPcHtyfy1%>w z(71)i8m1{*Dmr9khcfXxBPOAb6YIL!u~@H@6`FO!#CfTcp6{wV+gB%+M0cU@v$Df8 zPb3I+u%$S@oHFvi@pz0#EBt_0!u>I_^w1o1y6K4J(V|vgES0yXTTxt9QHou+ zr_S{~BU8df^dcne8&-0qR@bkOiyvvU3WiyZcB`M4H%@R%2=!Dxx=46b{sEJ#N_SHh1lgK)K&Y(DJ#`|#wlO92m|{Ow1aE*uc}nT#dBc08D;bBOdF4){GbC~7 zmXiLqy)mJTk3}?V=yKid)1qIqg4H>@DE2as^nrDuSJ%z9D-g?sXHs)_9PO~=>gzqQ#uWv&0{_V_Si*vuQiwJvO6 zYMAwPb($q*Z~(*Fr)l$Xq^XwX5R1{-AmhFEn>zR3B$nFxla$pi@J{7S@>V%|wt=+_ zR|6wbLh1CCSydbr?J%`RG}U*&eHs3^VKUg;R1b*-%X8U+_S{M>w(=O#->2I#qtxg9 zOM5KUM#CL-lmw#W4d-=XqNFUf!o0SxH8QO$81gn5>uYk;ou0E#rwDuv3a|Uw?0W}% z@+A*=#$_9q#hzBtEnmW}GJwTx{uGj8#Gpn~4%^6*3vk=NIySe<*1U-bE~(k`$n>%F z_{b+qFVi7roHRhAFY_{!dvCzlXbHsmIHw`1pQc{2sZHW$|LP9F2&`0HhB77R#^6FKX4F$13|y(xrk?y+I!`yZG=^e0N3Adv$Mr zLEAn-uk^$6&BS*qb~~?Y@8yt+a7(MuYz#AT5BI;C+PHRkSdm_>=&d5rkTpBaCHgFB zPvOX~T_jwqG4fc{P?uiOBViL+HCJA_Uj^=#C-ESN!?|B#G?0n z;B`lRMs42u!Jra!zouV$8uJO!IS^cplYtAW^XbNGWM%2I7$*t)r#5>Z&V)u~X-h`l zr4W4*`d;hi>02uO!>y!lr3#)*W;!!S!4qL%-S2dNZfrZ7Wy9@vR04B5sQ@EM)yx)E zi&0>8VOCB*UD(-Dcvh&tfq6;ry>CAo^fBzdh%WP!x5nIy)V)T&{CTUXB3BJdue{F$ zS<1q!DyxVq^r#F1fjwSB9pqqLZsz8W+Ph;Py!S9_+C~ZJ^=e{r^_E2tMf&qD5?*#3AxOZUJVIo@VYph$Vt6$J0sslNU^+=(b*44_EIN?d4h!W|k%G;->`~b5YL~ zP#=MV5veT<%0G4FAIa~oWrnkX)`djz<81B22EbODn> zh*zAY>u6O)wU&k!530*5&3h8)^0*(T$uqwA=<&TmO5n?8v2NjI_g3kvcNV*LrZKn* zpLH~zPlt6Lc&jb8l#r$m-)atJ;8kDI^AUW?D%Hdl;h$$^%qSY!IPaPW3wG8}cPuN< z<*9P>#?4*K&&93r?%Dy+N zq^oVfW=vtPSXx;$O{}rZWPrs)=PAW-y|UZxE&S~$2C6}xw(P9%#Nhsx8eN!Q8;?oC zh|zAE6ErR`n1Z0JxtZ0LOL^7CTOC^ z?Q}CmrT8HZBKgkNqm#Wcv$Idr344F4{SbYggcwk@BC4F8wSTBY>KS!dQN+<@%{(&Ao8M=Z?p%r)hDTleheZJzH9 zMQ&)R|E_Xr{kt-bn5hl-O>EE4VM*D0Y@8cS4@u)w)VlWKIrRE6wGLrA-}Lb(Qg9h{ z>nk^s0>2OcWRt3zje6Rn)7cA$mAjYGrPAq1q-dDybCS~30i4VL9kVZ&M+~1#>jfDqu}cHqXa*jQh8-IE1WHkIM?jO6)#??u~9Z>rQ5}~nux>>a|jb%1d*pa zdio+2dcdqS`7Hg1gh59Cl*EqHW~22{+r)^#mM(=&*CqmJiaQq zHxD%J(CU5h8lt3q81H*=lezwbwUN7NVwDvU7^`!?6adlX1$)&| zd1)9J@vu&)6sfp{aOn0cxs_`aNAaysp$~GT=aKp?B}pXH^W_b~bo|d0vYew^r`bcP zqV03Q;O&0bYo}fbBeJ-Ik`Cr`)<)mMjtGMf6iWAy<#E=F5v*|fPT8yJHbdMde$+!z z59S(Cm0E2)g1NS+e=gip_QAPLXTgbg&D7UlJR*|({7eH?YiXAX$pFMK3}r2&Se#rfD{to`em4H64e^4;tp`ANZoYPH(BW+ zo6$xW%<|m6iv1bBVJ)LQ;o6n?aN=2L`< z6q_5fFBi?c;oeK4&e3U8i95B%E!DAXNurg%M%X^7B|q#={u+C;&p6?ANF!CTx%q)d z+tk3Na)SK?Tbck0Q3YLa6dd?GUV%C5R=8ZP+9Ca8O(l1G)2b(?1}!)GPPBE5NLW%r z>mEnSN*yLE)xD+Z$31l%$lG%4pfNwnmzeZ4pwZ2)IC)_1e-$M{swu9(y1D^P)=vte zuaAd&#l#>FPOQo_Vykw42^PIKw>5qEuq9+a_k+w;kov@FfAUhn$5yw}R>qntYHCG?VK7kuPF7 zRYS5Ks7)r4ol`cE^y=E|T0@HS13pb?P{*k+adGQNZ8J`4_Cl#S=TAR;%H5y{lSh`O zIiws7f4{!Gm?@u4)ez|F!?kFCN}X;484?ZAGn9C?Pd)7qS`3bj{B1lSPbWKdShN~%-4TX{!@F}H!a z-PJ15hQM+%y;un6>VXL)Bn%5Wh!dh;tv}DQGWOe8U!w@>eUP_7Y6$hYge1?JAm_M= zEW_`eA2g5k>rb4Yl=5WI%4K!l0WXgeetT69?T&NTnX~Yx?=1w!)!3`)Si6nV#nZ}9 z9i|jfQS$c!s8hWf^Kar3z?U?Y3Ihlaq~`;%F)0ZdpG?=Se6bIfIr@#rQ|& zOCNtb^ee6_D(EpNhn5-VY7ZOZEO?efBH(svvR%|P^(d{ZF$9KT0y(>$qM+>61 z!rsV#1k*l+h{e$3gPKH@aY{F*Iufd@8~C;{5NX!>M%&10Zx{bZid&E)dd}) zSU49;-V1-4`duD$(Zz}UP#f5C;_HOG{I{!)yJedhcC{V%wR2i6>Wq&0xW{@LdO(Kk zppAs6-Rdx-d3W;Y?}@%AqZ0;t^3Q0rI=Yh7H{Ge}f(yErHrh|WOf(*Ad?nx3Sl%qD z*WfA6s&#cYm*fCL81e*|<*69#$cgb6ER_R_x0=4P)Rm~=bHqk)_x}hXyM6hw<*9*u zy7JRtGphk{$m6snuj^eamUe-`H}CIBBN5JTv#AD{Jw?7J(!u>dtwg-=BWR(L%Lt%z zY-Oy^KetQiAh_Up08I*RPbmZRB=~jEe(cDG?6a$VSxO|ns6*oqxM<>pifHTV*dHc!-x zTaTlTJHT!!Bjh%`uo8MYM=4%hUeh)yjFser$)c2W)3sbHC`oDkcRSg2}e%#4qbL#2SHA>@g*_e4jdw4oE>Q>YK#H`rN z+{WG}fcU*QY~Y6eA-U`#i-D2;%kHuyizf4t^{(+`Zz2v0dp0KvT|_k}O)lpw*xTFu zDYV9aP*cGR-*9JRUG4SYG2C$$h|yDzK^syQ)ifJ!<*^wpR{A19Ivf*$Ae6t{GP1Ki?= zP;v}>?d@+vlC+$gMqnR@_Qc*ShiHq*W{*CI?O`N^n(mwnvPX=vTB>AZHIcYe_D!-j z4wGBjOj;5~k7u7u5$woQ8gVH(1toaXG|8(^mbn^oEUE!x(r+Y~DE2R1#5PU+h>i6- zB>Y+x*-DS!PhR%g4>3yr>KoxEe@WD!Dl1|4+-2Vz9X~wydc9GEu<_JqiyR*2xT0D2 zi;VzQcdL`6xtqP`tt}T1j6TXU_Fg|}n&*2quGW^HF`(-IL_Y_c{-mq_XG0xz2ZmB( z+TIYvx6D7jr?f8i6iKlt+p&G{n=j~`w_N?i{BK5BVxG-xJqXcLhvj=j0-RtTwsKp*jG z5-*WTcHQiTotZI)3R+Y$6qn5grwy4oddxjqnbdsQZ0>ZEqqYJq-^swR0wx$pY2>%ui0Dz(qp6nCNxGL zuEEU?L0aSRqGA2nA6K`qYnaFglbV!%4t-tSp z-|YLER~Og@lX|RL^vt=Kr%%^1pN0y`gxq#4xQiC|4xVE8A;w?nEF0KIURVWs#EAt}HUk zM(8bJC(;zokYsGEtc-`jByL8y85WjQG?0-rRXalCkgsKPO5M=9sCb2StnL_5LhiKL zA1dfduUXA({-q-Ep05F9K$5#c^8Va(5Zk!uuc&2>Sbrm}6D76Rd98$Wj1?8<)3kmb z#rqcWv@gvpdp~h=TERqXO(a)S9285pJ?{WQsXHLdF-yliWjZ+-VL5$ESdheRQ5|Q_ z_Pp3|oLVukjf0x?uRDJSO-F8i$ChWMG2?`^qT8enEA(d`smXS z&pwj3$Fz4;bXS>Jr8o$_-0Cz<6AolzfL-<#)uHk1R99nY4!s#(>r?FJS}G-$#t-(t zgbs>XGEyR~;dSrYO)Z`6Vs@U%>_6`osFZtXmE7`7Td5;b-<$7Ibhc)q3Rr(>H4dk8 zG=`GZt&r#k!#35%{%EL+MVj+iOztGFB#UX^5iM1J<#gaYrEgs-SJitM)vDv;rQ2LK zeUmQBU{3e8rSRdnj}1vKe3m(cAZ*DIM@N{AGUFafw=XmiM+I*z zDz9~lX(Txc%kxVUzmZht%s;{b7&$QlY!E@=Z>cM!G%RV!(|DmYPfIF#4SteN7M-vI zNLs493>4gXXGDFCU|@8_vJMW$rc-C2SeDb zrghRpTx01(xYO?dt;atjwi(_dkDs*(2PH9UoE>~pucr77?zwY?{^133EB81UYCm@&fY7qN@dizP6dxQE!wq1)R+&rc*V?JoFT4tQe zQo8E`IpOc5AR6ViK!%#Zn6`<9jkw~f*{!mnW)mEh&~W-W$!)oKHEx#L#cylX(I#pg z8Zs%%yVZ9iI6JgSe;^?UFSAANIkYV9?^W}YG{5hwvDRr;Z{~d! zgI>5)|E|-zZMzjK^#S>A5Zlm2chfz*M?E36zGoD25a+U3mbm#1+@NP9YYWUw_5tX0 zPwa3X_xS~>W~Sa-4QwBtFd5t>=sQBzRF;w%iXl`vtIdP3LuKo0+pr*19!et+Is>an z?GLzTUmrl<)Nn)hgxF;1V=*W=eb#Z<{OE4-&u+G3_wk?-HGIm8CP_fb4(QCr|E0QciER6b%Lb-$BppAfq zAoW?1QClvKtC)+K(*xtz3|0l6wGA8GSR$`R2syfyz@^B?8 zQr7pUhuvoI{14+v-k21{k7t(+d{3}Wy!w37P>+wjn1blxBf&SyDl!dO32XA%uR{X} z3WByTu8|kKHNh97nvD9hkfLL5t3eW_#Q@LyFCI^ljg#{l=DvN{DHIDaZ2c_#+n0&9 zgJJxO?CRU(A==MEH7c$(_OtS6OnO3z$Y-%+U8jj6U5du!kJ(h+J9p&i$du)!`@h#@ zHt^Keh?^}_meqJrQFSXoKdG+meED?aF5|OX+s5#;%T>L){=K19T?Tv12{Mr+TI;M) zt5E}!f-P_nKRVnsMQTKHg0GIiO{m=^pT1=*83xl|OOM@ZRi9{<@;Y0>8D+4+TFkdh zi<|fzH<`ZpyZe!}A}8|WbGsOXKEuhH6yKtgY@^TCluWATfkyntw$qot)E?nK*|Bf3 zJ`#~a7U$v)$S>r_%;>kGe;*Ca^C{avCT6p=?A0mRw=devcHz+W%3>J zcDxgFzwn+-pG-~_!KevMWXN-{zpoGsFurmZt^QDytwvSQ!4pGi5y+*=7Ry>eDmcLO zc#&F?>PRqT*Jq8bxzPZ*yVKGhUXANwF_00fvrH|mmvE0`NcQ)r`$9PNN$(@HM#XPj z4~~5Oznog_hP#_)Nimn0Wp2MXvB{LeqmtU(Xoc5iepz4~$DIynpPBCRERZZqD=616 zvI=eT>P>LN`e7e2(0N*q#bL;8q0G8GcL&%yFFXx0FUn73(9Q@^A?mXebF zX-tW_=hbk%{-I5rEce--*3heyYIN~q+qPm2Q*?T5MK3X{(T&cgo+ce)LvocaVB5lL ztZJUUm%!TEydcy3y3Z!SL-M|?897REOHnmB?gF?V>juAMLw)Vo4X9^i6H^zp)Jq%<=D?=h?rf*4^pu$Il2Jbb6gck{TUfKp zl9tuBCjTLMydBBz9p!H(zQwhcM;w6meqStz)}@%H?Dj>8@peVoTdT^iTD$V=`Swv9 zE)=+iOaVqrH-Zye;+K!A!nvHE$(ogKX65E$S8?xcZ|CWX?dlCzYh)qW78b-P9% zF$M1$4tiMLK5B64GCt#9WEcG^p>MwzUI4q*sa9H7lKa&xC?z!X;*=$EiW1k1+{Qn` ztE_vu{SGKTt(+Mmszu63PDtL`{tC_oLIi_4A+6xRJH`b-JE zco%0dp@7{q*=4{MD3L-^x*$i!bat3Wx7+ZJav=mu#Wkil*ctlbi5MSSyjGL}qC)C=IlQg;fGum-D>&FmhqaoP*_4TbEgmAYc3eqCs-r{X zl<+>Cv!dMSvfD6ZKd5!OY0^l0HOEqRzHJ0{zvI{L@s#qgckzIFy;0LHMHO={Hk(ZN7Q6*w;g5_h$gIZ#+BqBhtSw!gAeq5Z3-Q zC08wpJ;J?u^j3vDZMia-hx@kWyMT*zTAiUkdQB7P37pGU1V;wPg|S5 z7q_P&ZT;y9i~84Z1<+(lHjL-ksU-$fl|X92&(SGAhEGqK;qR#_affpo{IDFOJ1aLY zm|n>?1WDUHqswkhNV?K~n`inL<`t zQ%Gg0!NWBo1pc^UW2f{T1zTTyus(*VqkR|iZHg?OG=C_Qu}{jH%BDv_Lio*~lDzLj z+vqEBN2(MDWsHg#59!hLR|z%ZthMlhXS^Q;@W-@LyN9x3T*4DRi+ursil@{&e3Q=G*HRS5Q`3UGl2FtfDe=2f1q^ zweC+UD6C6MFi{{8L`CwAX`ALvR`!78yYbPg>cskvEW9v8s^uPavC~G4xm|%cTZC(p z=Nt!`V{c zY0%c0ZZXYABzIe+O=No!+uh7gG8jk`2OWX1WPIF9#WtpkT1IEGUcAy#(f;wnvb^k8 zYf_6SrVzaUGl*&Rs$+iDu>eOkz(ib%ES9nW_3x+L%bJeKwEP!YVh^{EI)enMw!OUa!3(Xbm6xMgG$<&O_A8#E)+G^Q)aq9vs}8J-q`MYtqI& zECviRTc*FL=p1qx{HDSDLTNBXQ+OdTFn{;Jz%voT_GREEd1YS80t!x*eVn*5K8YFzoNeRt#GKH;?A= z(spdicMHmsDtcdioNT6f&4Ll-!}8lw#&OR7`g&eNj+VLNl;pLhyMIk4{1Juv*Y^}M zgq^LD8;e-zF7C1=GTq`d^E?i|wXxIz?bHBR<~aOD$E!jhGJ$!5$gR5FitosTi`Ba> z1#kr=Ft(Pzh=FzRnrORT3EVQbt9~pB=g`&2B-3=QeVAM1FGXv1RdOM1#yFPf9A}Nw z62@@{;7s{^IWA5@TDb`iRmw*Al(RLKy+yr&V7_s7B6M@{nSXj%9P!Of_*!_6>v2)@ z=*!{a=ZyTJ9(w}ozis(g4>9Pixk)z08{ZXykA)rt9?8qTJN2s9QGd5N5+h!n^1ijV zebRiV#@YEj72W$xH2RumLlB2ypLB%U{a zS@FPO8ae*O)jg|pLj5xJIwB)=PpY`RR!l2a=E{wA4Q|7WXM2*$LY~MNQ5aF)WD3@( zf59MqEuH!+X;FST%qy(|oi2c)EB{OB#G|6n=Ycg^WYd=+1H0`vbiU$ypdb2Q7{6F< zpp^{~jDN;!8?>?=4JU~qRINz&J)7;yR~kCynOb^9YL=D8^@UFIIBmIZ-5?EnsIfzb z482f_Ns79Yrq)MF(|(yXMGBgAE;C(c?CG>oz~zZt7fPXu>=NH#j=N>-?!y!+_wgR< zz`<$$s=y};i>$Vg(t8>VhtLne1_!{y1;VnZUz+N5#7UXjFg(rTeo$1?ZbXd`O%=(J zYrtFD-meo`GEjtE)owkU34m48n1OrMr4JI{Gs!8WkNAeMO%hf9qSRIP%g;RlimTeX z=#`_f)TAkhZCWM!mI0|jRtCSQ`_x@uou=bi?Q0l4&QE#0R5aPzp^k~6u(B;@@<;{w zxsl2Ai$3Z7mlPjzU;M<7@!iMcGsb{wvhhas$KpnS8L=}xkt+;@&!%uOjO1$EWiF6fMU~U{rjpkkYTPTWcA$Ji1$0qF)ANGc*?^66`AN?Q zzLQStvRgn3--$gfM^RTg-uh-HH8_;h!#*Ze2O;DGDEwn_%A9LVJw8WX)+SjZypCND zcA~#;u3Ck7)o?=0ui~H}VBnp=aqHU|)|_x_u~L$K65(c!{{Sq(qzeXJa#Z-c_}iZR zVDZm!&YYP-RVvevlS2})-HD3L=T7)weQ*X$0pVw|L};7pPZf5Vqd-1<-9ofWR`z8zqaStN`cge=E^eSi7ZxVzY@ES&1# zdr%Z-QdHL?K{R|z@zLSEU8=f{fsfBy&gn3!H-O_YkTMBam>lHp!+kTx$1isulcLot z_!YW#lA>zLN}7r4W2L8ot0YhhtCn9c2aG8sC~&fT zEGrEldSQjwvBu+S{V}+5J+qUZ{2gVKo7niIR$X~zJvOU*w}cQHuMSv-6;ezRrBf%5 zE=b%)M?LkY22ZH?F*zZ_+=h;dxLs~G+Ia45I~PE~rf&@rBi|f~Z$msXNYje|G7;iF2i=EODoHkg$*CY(*wl$^=xmcMhMU~Yw z6!Wbil;SCBVlrclfKE^CsLhXjkr?Hw6EAd8(o#w*poS$`48$vg@5#?Be-A8imN@OK zd|!d~SCzN=Dlq=S?RjB ztRRhU^_6tg4I9O_IiOc%RRd|p?SKz9263OE(;LN!`&Rz|xk{AQ!xqnlHc94}=PT<9 zsAJ*J3GpeS5PN>6 z!j09nDUf8grohm@I<1pT_%E+*^=VObw!KnTwcfcVgJ9gEkm2_G9k|<($CQ1w#gFfVV+o=sz&=m9&$!@pSB0+PPsX3!C|=!_PD{b9TYnpoJSAwZ zbY+7jTB^1)lZ=80{625QGD+=#nM;T0F)l=3j5ffX8yz%i9yFC#-hAD6;%=<1(Gu;#t=xPWcrhw9A~iOT0LwOU7=o@O|6#i z!l)%n9ZWLYKU zy^wg-RWy@E^5>2nh&-I}_(yzkt4j`f?zB~8#=lYi%9IUJ6~Mf09KcA#3@%FH9axND zu2%=X1A60Gq@=VlQ`qy<_3#+ubc#qME8r}fgP{s=19^^Dumtim$82h07T(B{(K@!b zr|LJ;T<3vll!&&5+VO*szEQ|N{{UQlGqMqDp)ICNyII!TW`*fmYK^YBXU=4g*OAB| z5P#E7QLU7_CUo?1%!?ITyGocvky{;(SM(t2Ur401#t|7;ggP@A!9v_*4^xl!)K|${ z9H}G{(#Il^g1(y8ouY?K{`#8(VC8fs6pXaoYSu*&O+m@hoQv^3O#T{fH)$?4ZX|r{ zP&+D*LH+o^=eE4`?nvszq!o^aIAtP54lsBpztj5b6yv&Pn9JbV;$Ia^OiG}~oAF~= zCm#cpj&%`*joDA=0QB|7tHqPZ19_6F2r7z9j|)eQsxU(wf!ouzwBnMw@={1$xx{JX zSQQ6{7SP8Wu?hjn{rJ||8La7Pw+qzt^yRzUHQRA!B7}((UZJ;veu*a^o^Ke=d$CqVG@iNgYK1O<6j!u|c;&P(KhN=SPqvjNpvZ;)+V3KjlkOzKFlj*HGLvwGjE1_s&SuPR6 zuAUu3cw#5Z;efyd`jOx5$9-${4YaJ!g(YR(@ajn$k?E84(<0?w*F_z9+3SB!SKGo~dJg3j z)Dti=(aVtosV6EAI3tBT4pec*uk}>5l@#FC;KCLzqn;S5Cc1P@$~nmbW{G@_!2C#f z2ZBQmKWjpHLAHtZg8j(xRt3B`vfv@~?0 z+-vCStrSw#PvF!CjL3y$r;$%7##d=x-u&t5S`^wrHK3}atCl|+Xx2s`tiEhHBWVfi z@8~|dN4dy`(Ek8vrK@77>+=Dl{9s@bJ0ENj#&r0_i){z(bj?da93%inP65s`dugzZ zMuP0_*&O3TB+#+-)SxiLk;be+0$Jio8CkgpOK7?B-%s6XY8Wj$s|6r^#xtMqt|XU( zdSeWmCyebUa2X!@&yy06*iMcS#6XN}Lsz zQWma5G0L(oP$AwArx^$OYMA3r%gN|pw^GSF4*2?wX_eQtXj0#On+hv*w+SUkgq3WDUl@KV6dV)B z87CPSJdxYJvd=rJ9UN-xtG+!{RwafuXR3}^m~aO5P1pov=Z{Pr5u9sh;q>Nb^=hIa zd=j2Gy2?dojSqn9xQ(ZhIl$x}zxUSv09vmZm(xFaVs$+{FF`dt^D~W(HorTM2O0Lr z{@Ul_d$eqyR48=iEYw{?aHkC{s%iXLb_2i7fC%TlFnj$uBUY9sd$yG-qRZnsuoW~oo;qX9i2caGL_tqzpQ+MFdprWhDJjXqX zjVgeVYQ4UB9t$~Ar zFg-nq&aVrExX7%kO3*5j{{VgIiN!72*sNb}WfLffzijX@H)QkMk&rTVsbG#xrYYoc z>^o}fNxFijJ7-T@>L9FDCS|Bb@ZpEmi5-YJ8-F*ZuPiafu1u%ZZ%DK3Ju_?-aMZ(4 zweHNJ_r|FSU(7S)yiH95>Hw^mo z>#dOVsk@Ui%PZ*&@Y=1E^k#|B$r}=XoaLAd6h!Yezk#EX;MCS{3` z7W_WiVvJU(qm-YM=FXeC)!8l(v=S2^iMtF2Fn_lLw;J>LBhPH=MbUS3<@TQ7All2m zL^)7%+n?-pmBeykZxl5+=e|cC<4fXCA}P2h0$;`39{&JsQQ}Opn@0qps=G||@X<>; z6=i1HQCE(4F~&6z^pkH$v&@%lDQ2}&*!I9F;(144vf?Hu9GsGHIKjZlCa;8bv1!5Q|R@x7nVa7&23$bA z&Y6$a$J$ZdGjnP#rl-1YEw!*nTr%W(k5Sxyn(kzWC~-NEl}gKws=aD$0-&oa22fBC zL$4eI-yG*$z8qw1a2ce>-mU{h*nOqz< zn;a4Be=o7;Se@i{`ZT1Vsdf%FDK33C9nRQ;=9VM9Ta&xDBL}~?Y#wzf@t+xV4P0$@ zNwC$_RP;Svc#cM^jwVTA9Av0$FW)C`KA?N)vci@{9|aWdHUaoU)O1$*ndz!3ycV8A zEG;78QJXmg@s;6#&mXwf%-CC|jPS|wI8@eEbydUoHIAJchk1sorg*@HF_H$>JQ7B5 z2R*ZlXG>Ayt(KI$A^W6yW{;<7MFkC4gEXuOn8BPStgBQyY}L_@{i#gMa`n$Q%sg16wfS;H~%jiJYzdh7nJf4$e0LjyTGnPy6;7 zf79LBPFkaFij272H~<1pI2tJ`BHJ{GM8C_96^WScF^mlRo;`H9s4r||P42(nqR#tl zMEI*y1Pa)rp01`v8$~OS>A}Hq{v4_8-?yf;~g?x6w>@(OC#&9#P6rklgM^Y}MvdXr6Klq7Y$TljeT?u0(KsLdF zg=GgI`XBYye7Kr+hQeB)-%i!s>(QY$`mrK0-aHn}XX*gsNm!)(7IH{Foj(C6x1#9- zuw2F&{{Vft$KQ;4>5;^|?2BVs{{RZMqnlMFDiDeSnujd0j&g&M&wl)#PN(YeRUHzc zZ(uvs-Uf)p3P(<|Wn>Q^AfEi3WROll_4;F2vd_t)5d+L-wApKFtE!}u1e0+xsA8zh z1`cz80q5zBV&(NFlucE}Ewf&Ss4-fSa~x{3ZkYH(3Hk%rW7AWSIZlX;D1*Kz+7D24 zt#u7Mfm7jl)ZT5X+esv6(<38W{U83hreyUV__Tb*ZlkDbLnQXAvQ6rlPq9FjM9e0YNI6NfB+t+I$2`Cw9?CDveZ3mG&Pkxw}z`Br@%PK_4LRd zzinrmQ+nup7Zq$DXO`r$wbH7wD-xXUc8i}VVCfWNBj?(ti0TI3pZ=c>Q$v$K+do z0)4K`dV=j$TP-CFR!B&cPEYe@B#bcG=2Sf8`w@fgL!9FkOTX|ZY_{w_!s+8MQcyuk zsUd|UMiHMjakR0)zPh@T>5$U!W$+UqjtDs%^X@b~EfBjaZ;ll4 zEfpmX3JY~Cf9rWy1bj8o2r2aQhTfv%&He8HL;Q++_#I#B;snJ1ZMH~tMFEbx;olg=u7AM1wp6Pypv)k>I zR;punG`=NF?i9(nfZnN$1sNb=K<&=C?;?(oyMvbe0)8s1R#IDyx(Mm#lC~;n7&|Ca zA;4}Aag6ab3~gKZ{dT(ATUKwKWH9by1*eC-?DrvR$33LK2>&R00~86!Tp_t!f$ zr^MBd3K+&tZeEhCB-zwq>4P zU}_0Kjbf>YQK@g`jhPYWv2WW^k=wPhBi6#S-34@&K4y-#mau0mc3}7P0P~G6`q*^U z1H&%RQr**6#;HnbYKnK8Ycj{M`N{4S_Bh9F3p8K)LxjFd2c|k#sI8T0C0!AQsg#H+ z839Bd>&YeYo-vR$86Bapjcu8~!*rs%MuI6Kkf-|_SfeAe?Pe;7IMm3mK9OYFS)bF(;oi1 zYE!+W4tk3uut{l%7--ph zt_UL^)M>3LL+mX!q*mV@<*0_!NFk<>#^IthTT3by!Bio6<&h45zL||v?1^qHs#4i@ zsVn@FG00%2X&-%TZ5ipAlHYM@3av^bg}`3_0IrKx6xt`-t@Sk$B_%~PvdVZ@iE#caAq_$_9ap)t_ zwbgY!J8$vlX){q$$3CTbU)b}k*>S~Xl`ny?li-2y+-qsNDjKLN9Vco~=0W(kG?*tn z^MZ9}6z4+RpAlAq-A7k5r9?Z|#Kt!f>-0KrCl#SJV~s7khK3fWq@;=%nY_x2joxf? z@5Zw7c^%2v)RO2C)%5VeFY=HsRE`d`q?0Jjd?&1_mg`eZB+T&A(@5~6auAK6eeen3 z>Yl3{QsrA@f~? z6%^s>QlaV5_Yt-+9(I5Z2h@R+>#O9)2Nv4i!ZVU-CRLV5(yHUswn~s@x5BiwP{8Do z46Z!vhq`A2AxIkKuH*g9&!!5hr-i4EW{epNEG3ELrygInn|=k7y7EaAq$mnI11qY& z58?$fLH%^bx)#~P;I%9jw(Fb~N#e&d)Kxevf9k6u2M4;HtVbBg@0<-XaZX58(k{M- zprfXuq?#&p3@Ubj-epm>Ny40glgS`+>#EP$#mD3qy3_aw^;cD2s4g(WNnhc{Vhl%u zhn)RaS$$8h^%(MTjJ5h9`2991M%n>%zgu-hZ&b%gQ*~(|YI=t$;YK-B1RfXA>p!Rb zL)1=Bl)OKIv-G%<)P4lssQ8W6u+hx$-=~eDtX+j;LB`|3^71$w9yG{$ywj_bB3N<7 z=?hoCh@Edsb)c3GrLRV)rB|2E2xHHo7$2sb+>&xl-|EF{s$a4`ocL*Rt-16yp1QuF zr>UL*(n!E%j!(9_-kNfF<7~yADNWEqXwr`2t4cg2k~6tS;oxzB*nXO(Sgcu7hPifH z4djF6x)!f<%RTbXO*03EwizO+LIxyVrLccdkbONh5u0&MmT^h6Qgu?v8Z#jQv)=<< w1*0<98cU66l#d;;_8PU5NVI+xNaYq{L6iJg8l!9+QDywyPyYba>P55v*>w&kHvj+t literal 0 HcmV?d00001 diff --git a/demos/imagenet/images/dog1.jpg b/demos/imagenet/images/dog1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eef50c9263dac05f2d377520ab09a64983a95138 GIT binary patch literal 12279 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 A0{{R3 literal 0 HcmV?d00001 diff --git a/demos/imagenet/images/dog2.jpg b/demos/imagenet/images/dog2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..41d3262748293de7deac6cbba1fe27cf32a1337b GIT binary patch literal 14872 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 ZrAmX7Ts3=2fwNv(l_~{l@|7wN|Jgi=)}a6Z literal 0 HcmV?d00001 diff --git a/demos/images/benchmark.png b/demos/images/benchmark.png new file mode 100644 index 0000000000000000000000000000000000000000..1527f1eefab78dec927c6b7f930d02950b6270a8 GIT binary patch literal 47293 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 literal 0 HcmV?d00001 diff --git a/demos/images/font-embedding.png b/demos/images/font-embedding.png new file mode 100644 index 0000000000000000000000000000000000000000..08e5b8092ea31299199890bb2ba102f8f4d988b0 GIT binary patch literal 57566 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%0DJSeEI`CqU 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%0A7D!kKZDoP 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 z≠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

Hu$Olup+|lV{v%{sAz1*R|ZI;u*ZGCzS4^P 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 z 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%0AB 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 ~J*b^JD8Ya~Y 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 literal 0 HcmV?d00001 diff --git a/demos/mnist/fully_connected_feed.py b/demos/mnist/fully_connected_feed.py new file mode 100644 index 0000000000..3a67796681 --- /dev/null +++ b/demos/mnist/fully_connected_feed.py @@ -0,0 +1,253 @@ +# Copyright 2017 Google Inc. 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. +# ============================================================================== +"""Trains and Evaluates the MNIST network using a feed dictionary.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +# pylint: disable=missing-docstring +import argparse +import os +import sys +import time + +from six.moves import xrange # pylint: disable=redefined-builtin +import tensorflow as tf + +from tensorflow.examples.tutorials.mnist import input_data +from tensorflow.examples.tutorials.mnist import mnist + +# Basic model parameters as external flags. +FLAGS = None + + +def placeholder_inputs(batch_size): + """Generate placeholder variables to represent the input tensors. + + These placeholders are used as inputs by the rest of the model building + code and will be fed from the downloaded data in the .run() loop, below. + + Args: + batch_size: The batch size will be baked into both placeholders. + + Returns: + images_placeholder: Images placeholder. + labels_placeholder: Labels placeholder. + """ + # Note that the shapes of the placeholders match the shapes of the full + # image and label tensors, except the first dimension is now batch_size + # rather than the full size of the train or test data sets. + images_placeholder = tf.placeholder( + tf.float32, shape=(batch_size, mnist.IMAGE_PIXELS)) + labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size)) + return images_placeholder, labels_placeholder + + +def fill_feed_dict(data_set, images_pl, labels_pl): + """Fills the feed_dict for training the given step. + + A feed_dict takes the form of: + feed_dict = { + : , + .... + } + + Args: + data_set: The set of images and labels, from input_data.read_data_sets() + images_pl: The images placeholder, from placeholder_inputs(). + labels_pl: The labels placeholder, from placeholder_inputs(). + + Returns: + feed_dict: The feed dictionary mapping from placeholders to values. + """ + # Create the feed_dict for the placeholders filled with the next + # `batch size` examples. + images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size, + FLAGS.fake_data) + feed_dict = { + images_pl: images_feed, + labels_pl: labels_feed, + } + return feed_dict + + +def do_eval(sess, eval_correct, images_placeholder, labels_placeholder, + data_set): + """Runs one evaluation against the full epoch of data. + + Args: + sess: The session in which the model has been trained. + eval_correct: The Tensor that returns the number of correct predictions. + images_placeholder: The images placeholder. + labels_placeholder: The labels placeholder. + data_set: The set of images and labels to evaluate, from + input_data.read_data_sets(). + """ + # And run one epoch of eval. + true_count = 0 # Counts the number of correct predictions. + steps_per_epoch = data_set.num_examples // FLAGS.batch_size + num_examples = steps_per_epoch * FLAGS.batch_size + for step in xrange(steps_per_epoch): + feed_dict = fill_feed_dict(data_set, images_placeholder, labels_placeholder) + true_count += sess.run(eval_correct, feed_dict=feed_dict) + precision = float(true_count) / num_examples + print(' Num examples: %d Num correct: %d Precision @ 1: %0.04f' % + (num_examples, true_count, precision)) + + +def run_training(): + """Train MNIST for a number of steps.""" + # Get the sets of images and labels for training, validation, and + # test on MNIST. + data_sets = input_data.read_data_sets(FLAGS.input_data_dir, FLAGS.fake_data) + + # Tell TensorFlow that the model will be built into the default Graph. + with tf.Graph().as_default(): + # Generate placeholders for the images and labels. + images_placeholder, labels_placeholder = placeholder_inputs( + FLAGS.batch_size) + + # Build a Graph that computes predictions from the inference model. + logits = mnist.inference(images_placeholder, FLAGS.hidden1, FLAGS.hidden2) + + # Add to the Graph the Ops for loss calculation. + loss = mnist.loss(logits, labels_placeholder) + + # Add to the Graph the Ops that calculate and apply gradients. + train_op = mnist.training(loss, FLAGS.learning_rate) + + # Add the Op to compare the logits to the labels during evaluation. + eval_correct = mnist.evaluation(logits, labels_placeholder) + + # Build the summary Tensor based on the TF collection of Summaries. + summary = tf.summary.merge_all() + + # Add the variable initializer Op. + init = tf.global_variables_initializer() + + # Create a saver for writing training checkpoints. + saver = tf.train.Saver() + + # Create a session for running Ops on the Graph. + sess = tf.Session() + + # Instantiate a SummaryWriter to output summaries and the Graph. + summary_writer = tf.summary.FileWriter(FLAGS.log_dir, sess.graph) + + # And then after everything is built: + + # Run the Op to initialize the variables. + sess.run(init) + + # Start the training loop. + for step in xrange(FLAGS.max_steps): + start_time = time.time() + + # Fill a feed dictionary with the actual set of images and labels + # for this particular training step. + feed_dict = fill_feed_dict(data_sets.train, images_placeholder, + labels_placeholder) + + # Run one step of the model. The return values are the activations + # from the `train_op` (which is discarded) and the `loss` Op. To + # inspect the values of your Ops or variables, you may include them + # in the list passed to sess.run() and the value tensors will be + # returned in the tuple from the call. + _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict) + + duration = time.time() - start_time + + # Write the summaries and print an overview fairly often. + if step % 100 == 0: + # Print status to stdout. + print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration)) + # Update the events file. + summary_str = sess.run(summary, feed_dict=feed_dict) + summary_writer.add_summary(summary_str, step) + summary_writer.flush() + + # Save a checkpoint and evaluate the model periodically. + if (step + 1) % 1000 == 0 or (step + 1) == FLAGS.max_steps: + checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt') + saver.save(sess, checkpoint_file, global_step=step) + # Evaluate against the training set. + print('Training Data Eval:') + do_eval(sess, eval_correct, images_placeholder, labels_placeholder, + data_sets.train) + # Evaluate against the validation set. + print('Validation Data Eval:') + do_eval(sess, eval_correct, images_placeholder, labels_placeholder, + data_sets.validation) + # Evaluate against the test set. + print('Test Data Eval:') + do_eval(sess, eval_correct, images_placeholder, labels_placeholder, + data_sets.test) + + +def main(_): + if tf.gfile.Exists(FLAGS.log_dir): + tf.gfile.DeleteRecursively(FLAGS.log_dir) + tf.gfile.MakeDirs(FLAGS.log_dir) + run_training() + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument( + '--learning_rate', + type=float, + default=0.01, + help='Initial learning rate.') + parser.add_argument( + '--max_steps', + type=int, + default=2000, + help='Number of steps to run trainer.') + parser.add_argument( + '--hidden1', + type=int, + default=128, + help='Number of units in hidden layer 1.') + parser.add_argument( + '--hidden2', + type=int, + default=32, + help='Number of units in hidden layer 2.') + parser.add_argument( + '--batch_size', + type=int, + default=100, + help='Batch size. Must divide evenly into the dataset sizes.') + parser.add_argument( + '--input_data_dir', + type=str, + default=os.path.join( + os.getenv('TEST_TMPDIR', '/tmp'), 'tensorflow/mnist/input_data'), + help='Directory to put the input data.') + parser.add_argument( + '--log_dir', + type=str, + default=os.path.join( + os.getenv('TEST_TMPDIR', '/tmp'), + 'tensorflow/mnist/logs/fully_connected_feed'), + help='Directory to put the log data.') + parser.add_argument( + '--fake_data', + default=False, + help='If true, uses fake data for unit testing.', + action='store_true') + + FLAGS, unparsed = parser.parse_known_args() + tf.app.run(main=main, argv=[sys.argv[0]] + unparsed) diff --git a/demos/mnist/hidden1_biases b/demos/mnist/hidden1_biases new file mode 100644 index 0000000000..93296ad8d3 --- /dev/null +++ b/demos/mnist/hidden1_biases @@ -0,0 +1,3 @@ +ÞžI¼ð*Ò<ú ;Ÿ?9'¤=»Ç÷ ;X„÷<ªþ=ÇH:=#ñ ;ùYè<ºy6=Òú=±Ô¸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

gj+na*6&WW}cyuxDZ^Y<8IlcYPeV=t=p&<{sf{ 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

fn* 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

MNIST demo

+
Test accuracy:
+ diff --git a/demos/mnist/manifest.json b/demos/mnist/manifest.json new file mode 100644 index 0000000000..3a39b577ac --- /dev/null +++ b/demos/mnist/manifest.json @@ -0,0 +1,41 @@ +{ + "hidden1/biases": { + "filename": "hidden1_biases", + "shape": [ + 128 + ] + }, + "hidden1/weights": { + "filename": "hidden1_weights", + "shape": [ + 784, + 128 + ] + }, + "hidden2/biases": { + "filename": "hidden2_biases", + "shape": [ + 32 + ] + }, + "hidden2/weights": { + "filename": "hidden2_weights", + "shape": [ + 128, + 32 + ] + }, + "softmax_linear/biases": { + "filename": "softmax_linear_biases", + "shape": [ + 10 + ] + }, + "softmax_linear/weights": { + "filename": "softmax_linear_weights", + "shape": [ + 32, + 10 + ] + } +} diff --git a/demos/mnist/mnist.md b/demos/mnist/mnist.md new file mode 100644 index 0000000000..02d9b71724 --- /dev/null +++ b/demos/mnist/mnist.md @@ -0,0 +1,125 @@ +--- +layout: page +order: 4 +--- + +# Port TensorFlow models +This tutorial demonstrates training and porting a TensorFlow model to **deeplearn.js**. +The code and all the necessary resources used in this tutorial are stored in +`demos/mnist`. + +We will use a fully connected neural network that predicts hand-written digits +from the MNIST dataset. The code is forked from the official +[TensorFlow MNIST tutorial](https://github.com/tensorflow/tensorflow/blob/r1.2/tensorflow/examples/tutorials/mnist/fully_connected_feed.py). + +> NOTE: We will refer to the base directory of the **deeplearn.js** repo as `$BASE`. + +First, we clone the **deeplearn.js** repository and make sure we have TensorFlow +installed. We cd into `$BASE` and train the model by running: + +```bash +python demos/mnist/fully_connected_feed.py +``` + +The training should take ~1 minute and will store a model checkpoint in +`/tmp/tensorflow/mnist/tensorflow/mnist/logs/fully_connected_feed/`. + +Next, we need to port the weights from the TensorFlow checkpoint to **deeplearn.js**. +We provide a script that does this. We run it from the `$BASE` directory: + +```bash +python scripts/dump_checkpoint_vars.py --output_dir=demos/mnist/ --checkpoint_file=/tmp/tensorflow/mnist/logs/fully_connected_feed/model.ckpt-1999 +``` + +The script will save a set of files (one file per variable, and a +`manifest.json`) in the `demos/mnist` directory. The `manifest.json` is a simple +dictionary that maps variable names to files and their shapes: + +```json +{ + ..., + "hidden1/weights": { + "filename": "hidden1_weights", + "shape": [784, 128] + }, + ... +} +``` + +One last thing before we start coding - we need to run a static HTTP server from +the `$BASE` directory. + +```bash +./node_modules/.bin/http-server +>> Starting up http-server, serving ./ +>> Available on: +>> http://127.0.0.1:8080 +>> Hit CTRL-C to stop the server +``` + +Make sure you can access `manifest.json` via HTTP by visiting +`http://localhost:8080/demos/mnist/manifest.json` in the browser. + +We are ready to write some **deeplearn.js** code! + +> NOTE: If you choose to write in TypeScript, +make sure you compile the code to JavaScript and serve it via the static HTTP +server. + + +To read the weights, we need to create a `CheckpointLoader` and point it to the +manifest file. We then call `loader.getAllVariables()` which returns a +dictionary that maps variable names to `NDArray`s. At that point, we are ready +to write our model. Here is a snippet demonstrating the use of +`CheckpointLoader`: + +```ts +import {CheckpointLoader, Graph} from 'deeplearnjs'; +// manifest.json is in the same dir as index.html. +const reader = new CheckpointReader('.'); +reader.getAllVariables().then(vars => { + // Write your model here. + const g = new Graph(); + const input = g.placeholder('input', [784]); + const hidden1W = g.constant(vars['hidden1/weights']); + const hidden1B = g.constant(vars['hidden1/biases']); + const hidden1 = g.relu(g.add(g.matmul(input, hidden1W), hidden1B)); + ... + ... +}); +``` + +For details regarding the full model code see `demos/mnist/mnist.ts`. The demo +provides the exact implementation of the MNIST model using 3 different API: + +- `buildModelGraphAPI()` uses the Graph API which mimics the TensorFlow API, +providing a lazy execution with feeds and fetches. Users do not need to worry +about GPU-related memory leaks, other than their input data. +- `buildModelLayerAPI()` uses the Graph API in conjuction with `Graph.layers`, +which mimics the Keras layers API. +- `buildModelMathAPI()` uses the Math API. This is the lowest level API in +**deeplearn.js** giving the most control to the user. Math commands execute immediately, +like numpy. Math commands are wrapped in math.scope() so that NDArrays created +by intermediate math commands are automatically cleaned up. + +To run the mnist demo, we provide a `watch-demo` script that watches and +recompiles the typescript code when it changes. In addition, the script runs a +simple HTTP server on 8080 that serves the static html/js files. Before you run +`watch-demo`, make sure you kill the HTTP server we started earlier in the +tutorial in order to free up the 8080 port. Then run `watch-demo` from `$BASE` +pointed to the entry-point of the web app demo, `demos/mnist/mnist.ts`: + +```bash +/scripts/watch-demo demos/mnist/mnist.ts +>> Starting up http-server, serving ./ +>> Available on: +>> http://127.0.0.1:8080 +>> http://192.168.1.5:8080 +>> Hit CTRL-C to stop the server +>> 1410084 bytes written to demos/mnist/bundle.js (0.91 seconds) at 5:17:45 PM +``` + +Visit `http://localhost:8080/demos/mnist/` and you should see a simple page +showing test accuracy of ~90% measured using a test set of 50 mnist images +stored in `demos/mnist/sample_data.json`. Feel free to play with the demo +(e.g. make it more interactive) and send us a pull request! diff --git a/demos/mnist/mnist.ts b/demos/mnist/mnist.ts new file mode 100644 index 0000000000..d8cb7dde92 --- /dev/null +++ b/demos/mnist/mnist.ts @@ -0,0 +1,139 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Array1D, Array2D, CheckpointLoader, Graph, NDArray, NDArrayInitializer, NDArrayMath, NDArrayMathGPU, Scalar, Session, Tensor} from '../deeplearnjs'; + +// manifest.json lives in the same directory as the mnist demo. +const reader = new CheckpointLoader('.'); +reader.getAllVariables().then(vars => { + // Get sample data. + const xhr = new XMLHttpRequest(); + xhr.open('GET', 'sample_data.json'); + xhr.onload = () => { + const data = JSON.parse(xhr.responseText) as SampleData; + const math = new NDArrayMathGPU(); + const evalMethod = buildModelMathAPI(math, data, vars); + const [input, probs] = buildModelLayersAPI(data, vars); + const [input2, probs2] = buildModelGraphAPI(data, vars); + const sess = new Session(input.node.graph, math); + + math.scope(() => { + let numCorrect = 0; + for (let i = 0; i < data.images.length; i++) { + const inputData = Array1D.new(data.images[i]); + const probsVal = sess.eval(probs, [{tensor: input, data: inputData}]); + const probsVal2 = + sess.eval(probs2, [{tensor: input2, data: inputData}]); + const probsVal3 = evalMethod(inputData); + if (data.labels[i] === probsVal.get()) { + numCorrect++; + } + } + const accuracy = numCorrect * 100 / data.images.length; + document.getElementById('accuracy')!.innerHTML = accuracy + '%'; + }); + }; + xhr.onerror = (err) => console.error(err); + xhr.send(); +}); + +interface SampleData { + images: number[][]; + labels: number[]; +} + +/** + * Builds a 3-layer fully connected MNIST model using the Math API. This is the + * lowest level user-facing API in Learn.js giving the most control to the user. + * Math commands execute immediately, like numpy. Math commands are wrapped in + * math.scope() so that NDArrays created by intermediate math commands are + * automatically cleaned up. + */ +function buildModelMathAPI( + math: NDArrayMath, data: SampleData, + vars: {[varName: string]: NDArray}): (x: Array1D) => Scalar { + const hidden1W = vars['hidden1/weights'] as Array2D; + const hidden1B = vars['hidden1/biases'] as Array1D; + const hidden2W = vars['hidden2/weights'] as Array2D; + const hidden2B = vars['hidden2/biases'] as Array1D; + const softmaxW = vars['softmax_linear/weights'] as Array2D; + const softmaxB = vars['softmax_linear/biases'] as Array1D; + + return (x: Array1D): Scalar => { + return math.scope(() => { + const hidden1 = + math.relu(math.add(math.vectorTimesMatrix(x, hidden1W), hidden1B)); + const hidden2 = math.relu( + math.add(math.vectorTimesMatrix(hidden1, hidden2W), hidden2B)); + const logits = + math.add(math.vectorTimesMatrix(hidden2, softmaxW), softmaxB); + return math.argMax(logits); + }); + }; +} + +/** + * Builds a 3-layers fully connected MNIST model using the Graph API. This API + * mimics the TensorFlow API, providing a lazy execution with feeds and fetches. + * Users do not need to worry about GPU-related memory leaks, other than their + * input data. + */ +function buildModelGraphAPI( + data: SampleData, vars: {[varName: string]: NDArray}): Tensor[] { + const g = new Graph(); + // TODO: Support batching. + const input = g.placeholder('input', [784]); + const hidden1W = g.constant(vars['hidden1/weights']); + const hidden1B = g.constant(vars['hidden1/biases']); + const hidden1 = g.relu(g.add(g.matmul(input, hidden1W), hidden1B)); + + const hidden2W = g.constant(vars['hidden2/weights']); + const hidden2B = g.constant(vars['hidden2/biases']); + const hidden2 = g.relu(g.add(g.matmul(hidden1, hidden2W), hidden2B)); + + const softmaxW = g.constant(vars['softmax_linear/weights']); + const softmaxB = g.constant(vars['softmax_linear/biases']); + const logits = g.add(g.matmul(hidden2, softmaxW), softmaxB); + return [input, g.argmax(logits)]; +} + +/** + * Builds a 3-layers fully connected MNIST model using the Graph API in + * conjuction with `Graph.layers`, which mimics the Keras layers API. + */ +function buildModelLayersAPI( + data: SampleData, vars: {[varName: string]: NDArray}): Tensor[] { + const g = new Graph(); + // TODO: Support batching. + const input = g.placeholder('input', [784]); + const hidden1W = vars['hidden1/weights']; + const hidden1B = vars['hidden1/biases']; + const hidden1 = g.layers.dense( + 'hidden1', input, hidden1W.shape[1], (x) => g.relu(x), true, + new NDArrayInitializer(hidden1W), new NDArrayInitializer(hidden1B)); + + const hidden2W = vars['hidden2/weights']; + const hidden2B = vars['hidden2/biases']; + const hidden2 = g.layers.dense( + 'hidden2', hidden1, hidden2W.shape[1], (x) => g.relu(x), true, + new NDArrayInitializer(hidden2W), new NDArrayInitializer(hidden2B)); + + const softmaxW = vars['softmax_linear/weights']; + const softmaxB = vars['softmax_linear/biases']; + const logits = g.layers.dense( + 'softmax', hidden2, softmaxW.shape[1], null, true, + new NDArrayInitializer(softmaxW), new NDArrayInitializer(softmaxB)); + return [input, g.argmax(logits)]; +} diff --git a/demos/mnist/sample_data.json b/demos/mnist/sample_data.json new file mode 100644 index 0000000000..af250795b1 --- /dev/null +++ b/demos/mnist/sample_data.json @@ -0,0 +1 @@ +{"images": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.412, 0.533, 0.702, 0.792, 0.706, 0.447, 0.071, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.188, 0.953, 0.996, 0.996, 0.996, 0.996, 0.855, 0.996, 0.863, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.302, 0.941, 0.898, 0.384, 0.353, 0.42, 0.455, 0.145, 0.816, 0.992, 0.647, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.706, 0.996, 0.847, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.639, 0.996, 0.761, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.91, 0.996, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.949, 0.996, 0.588, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.996, 0.247, 0.0, 0.0, 0.0, 0.031, 0.329, 0.929, 0.996, 0.518, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.396, 0.996, 0.984, 0.42, 0.0, 0.031, 0.675, 0.996, 0.996, 0.525, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.302, 0.941, 0.984, 0.765, 0.776, 0.996, 0.851, 0.282, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.286, 0.996, 0.996, 1.0, 0.882, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.996, 0.996, 0.996, 0.969, 0.31, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.133, 0.965, 0.976, 0.451, 0.965, 0.996, 0.878, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.812, 0.996, 0.592, 0.0, 0.369, 0.953, 0.996, 0.671, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.69, 0.996, 0.627, 0.016, 0.0, 0.0, 0.631, 0.996, 0.996, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42, 1.0, 0.675, 0.016, 0.0, 0.0, 0.0, 0.529, 0.996, 0.996, 0.255, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.157, 0.98, 0.996, 0.298, 0.0, 0.0, 0.0, 0.0, 0.443, 0.996, 0.996, 0.325, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.996, 0.882, 0.055, 0.0, 0.0, 0.0, 0.0, 0.529, 0.996, 0.976, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.761, 0.996, 0.827, 0.0, 0.0, 0.0, 0.0, 0.133, 0.863, 0.996, 0.506, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.996, 0.957, 0.337, 0.004, 0.0, 0.02, 0.706, 0.996, 0.749, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.094, 0.835, 0.996, 0.996, 0.671, 0.522, 0.831, 0.996, 0.694, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.325, 0.651, 0.804, 0.91, 0.91, 0.463, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.369, 0.0, 0.184, 0.588, 0.992, 0.992, 1.0, 0.827, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.812, 0.969, 0.525, 0.914, 0.988, 0.988, 0.988, 0.992, 0.988, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.831, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.992, 0.988, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.565, 0.992, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.992, 0.988, 0.604, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.71, 0.988, 0.992, 0.988, 0.988, 0.988, 0.992, 0.62, 0.561, 0.561, 0.992, 0.988, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.788, 0.988, 0.992, 0.988, 0.988, 0.502, 0.137, 0.02, 0.0, 0.0, 0.827, 0.988, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.71, 0.988, 0.988, 0.992, 0.945, 0.439, 0.122, 0.0, 0.0, 0.0, 0.0, 0.506, 0.988, 0.439, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.988, 0.988, 0.988, 0.992, 0.38, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.004, 0.671, 0.992, 0.992, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.247, 1.0, 0.992, 0.282, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.608, 0.988, 0.988, 0.702, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.929, 0.992, 0.906, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.145, 0.988, 0.988, 0.988, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.988, 0.992, 0.62, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.988, 0.988, 0.824, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.867, 0.988, 0.749, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.831, 0.992, 0.808, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.914, 0.992, 0.992, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.451, 0.988, 0.988, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.608, 0.914, 0.988, 0.988, 0.988, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.851, 0.988, 0.988, 0.867, 0.224, 0.145, 0.145, 0.145, 0.306, 0.749, 0.988, 0.992, 0.988, 0.965, 0.518, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.851, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.992, 0.988, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.855, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.992, 0.992, 1.0, 0.624, 0.161, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.686, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.824, 0.467, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.706, 0.988, 0.988, 0.988, 0.988, 0.988, 0.992, 0.945, 0.843, 0.361, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.424, 0.988, 0.988, 0.988, 0.988, 0.749, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.851, 0.996, 0.902, 0.071, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.494, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.557, 0.992, 0.996, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.992, 0.996, 0.941, 0.149, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.992, 0.996, 0.992, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.992, 0.996, 0.992, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.992, 0.996, 0.992, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.847, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.851, 0.996, 1.0, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.847, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.98, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.992, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.992, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.992, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.992, 0.992, 0.996, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.141, 0.937, 0.992, 0.761, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.486, 0.988, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.424, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.149, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.91, 0.988, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.188, 1.0, 0.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.996, 0.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.588, 0.996, 0.471, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.871, 0.996, 0.114, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.329, 0.996, 0.847, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.573, 0.996, 0.38, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.906, 0.988, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.235, 0.996, 0.663, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.624, 0.996, 0.325, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.945, 0.804, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.267, 0.996, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.004, 0.835, 0.929, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.996, 0.51, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.408, 0.949, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.608, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.404, 0.996, 0.871, 0.996, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.875, 0.976, 0.914, 0.78, 0.976, 0.847, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.349, 0.933, 0.918, 0.541, 0.09, 0.0, 0.922, 0.847, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.212, 0.757, 0.973, 0.843, 0.157, 0.0, 0.0, 0.251, 0.976, 0.541, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.486, 0.933, 0.992, 0.329, 0.0, 0.0, 0.0, 0.0, 0.894, 0.992, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.945, 0.973, 0.329, 0.0, 0.0, 0.0, 0.024, 0.667, 1.0, 0.451, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.545, 0.988, 0.882, 0.341, 0.0, 0.0, 0.0, 0.031, 0.651, 0.992, 0.753, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.996, 0.831, 0.247, 0.0, 0.0, 0.0, 0.11, 0.824, 0.992, 0.992, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.235, 0.933, 0.847, 0.118, 0.0, 0.0, 0.0, 0.0, 0.647, 0.992, 0.992, 0.992, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.855, 0.863, 0.102, 0.0, 0.0, 0.027, 0.357, 0.584, 0.973, 0.992, 0.992, 0.992, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.996, 0.412, 0.0, 0.165, 0.467, 0.792, 0.996, 0.714, 0.357, 0.451, 0.996, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.573, 0.992, 0.941, 0.925, 0.961, 0.992, 0.898, 0.522, 0.027, 0.0, 0.22, 0.992, 0.635, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.773, 0.847, 0.902, 0.773, 0.318, 0.082, 0.0, 0.0, 0.0, 0.675, 0.98, 0.294, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.169, 0.961, 0.922, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.341, 0.992, 0.663, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.969, 0.902, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.992, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.18, 0.945, 0.808, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.969, 0.871, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.51, 0.71, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.416, 1.0, 0.882, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.612, 0.992, 0.992, 0.992, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.82, 0.992, 0.992, 0.992, 0.776, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.176, 0.8, 0.996, 0.992, 0.992, 0.776, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.094, 0.925, 0.992, 0.996, 0.992, 0.776, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.384, 0.992, 0.992, 0.984, 0.663, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.812, 0.992, 0.992, 0.949, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.741, 0.992, 0.992, 0.812, 0.133, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.467, 0.976, 0.992, 0.992, 0.518, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.871, 0.992, 0.992, 0.788, 0.043, 0.0, 0.0, 0.0, 0.322, 0.478, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.729, 0.996, 0.996, 0.98, 0.09, 0.047, 0.525, 0.796, 0.996, 1.0, 0.996, 0.996, 0.839, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.992, 0.992, 0.961, 0.412, 0.525, 0.976, 0.996, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.714, 0.992, 0.992, 0.867, 0.941, 0.992, 0.992, 0.996, 0.98, 0.851, 0.878, 0.992, 0.992, 0.784, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.235, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.902, 0.784, 0.298, 0.027, 0.569, 0.992, 0.992, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.616, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.631, 0.118, 0.024, 0.573, 0.992, 0.992, 0.451, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.616, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.875, 0.78, 0.992, 0.992, 0.788, 0.169, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.616, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.929, 0.188, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.616, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.757, 0.498, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.976, 0.518, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.365, 0.518, 0.882, 0.992, 0.992, 0.788, 0.518, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.208, 0.561, 0.561, 0.996, 0.992, 0.992, 0.992, 0.898, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.357, 0.835, 0.988, 0.988, 0.988, 0.992, 0.808, 0.831, 0.988, 0.988, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.353, 0.953, 0.988, 0.922, 0.6, 0.416, 0.173, 0.051, 0.067, 0.957, 0.988, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.741, 0.753, 0.267, 0.035, 0.0, 0.0, 0.0, 0.0, 0.035, 0.953, 0.988, 0.231, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.486, 0.988, 0.847, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.953, 0.988, 0.435, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.482, 0.988, 0.929, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.396, 0.988, 0.988, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.694, 0.988, 0.871, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.992, 0.988, 0.416, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.694, 1.0, 0.733, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42, 0.988, 0.961, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.145, 0.945, 0.988, 0.506, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.004, 0.62, 0.988, 0.988, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.329, 0.988, 0.988, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.478, 0.988, 0.988, 0.129, 0.0, 0.0, 0.0, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.682, 0.988, 0.502, 0.012, 0.027, 0.349, 0.835, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.906, 0.988, 0.573, 0.176, 0.824, 0.945, 0.463, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.584, 0.988, 0.988, 0.988, 0.992, 0.596, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.82, 0.988, 0.8, 0.318, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.753, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.867, 0.882, 0.196, 0.333, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.451, 0.992, 0.957, 0.988, 0.557, 0.051, 0.122, 0.671, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.69, 0.992, 0.988, 0.988, 0.988, 0.851, 0.855, 0.988, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.137, 0.827, 0.992, 0.816, 0.988, 0.988, 0.988, 0.992, 0.988, 0.839, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.992, 0.992, 0.929, 0.388, 0.914, 0.992, 0.992, 0.996, 0.992, 0.925, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.988, 0.988, 0.992, 0.659, 0.737, 0.988, 0.988, 0.992, 0.988, 0.988, 0.722, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.988, 0.988, 0.992, 0.686, 0.918, 0.969, 0.561, 0.925, 0.988, 0.988, 0.988, 0.749, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.769, 0.988, 0.992, 0.988, 0.867, 0.384, 0.0, 0.055, 0.471, 0.867, 0.988, 0.988, 0.518, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.494, 0.988, 0.992, 0.714, 0.082, 0.0, 0.0, 0.0, 0.0, 0.118, 0.576, 0.922, 0.969, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.349, 0.176, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 1.0, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.329, 0.745, 0.314, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.106, 0.992, 0.906, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.988, 0.62, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.961, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.557, 0.988, 0.937, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.992, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.988, 0.992, 0.937, 0.62, 0.137, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.992, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 0.996, 0.992, 0.992, 0.992, 0.82, 0.58, 0.216, 0.188, 0.58, 0.925, 0.969, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.992, 0.988, 0.988, 0.988, 0.988, 0.992, 0.906, 0.969, 0.988, 0.851, 0.655, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.565, 0.969, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.957, 0.827, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.388, 0.969, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.988, 0.725, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.165, 0.682, 0.992, 0.988, 0.988, 0.886, 0.231, 0.071, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.278, 0.608, 0.992, 0.996, 0.996, 0.996, 0.89, 0.396, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.443, 0.878, 0.992, 0.992, 0.973, 0.953, 0.71, 0.588, 0.992, 0.894, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.682, 0.992, 0.992, 0.792, 0.349, 0.145, 0.0, 0.0, 0.059, 0.992, 0.894, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.871, 0.396, 0.063, 0.0, 0.0, 0.0, 0.0, 0.4, 0.992, 0.894, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.718, 0.992, 0.741, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.459, 0.98, 0.992, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.541, 0.992, 0.973, 0.553, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.773, 0.984, 0.957, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.671, 0.992, 0.992, 0.847, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.463, 0.914, 0.992, 0.992, 0.992, 0.718, 0.145, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.192, 0.286, 0.761, 0.992, 0.863, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.478, 0.969, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.878, 0.945, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.89, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.878, 0.992, 0.471, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.761, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.89, 0.992, 0.275, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.992, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.655, 0.992, 0.894, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.255, 0.953, 0.984, 0.635, 0.086, 0.0, 0.0, 0.059, 0.231, 0.71, 0.992, 0.996, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.396, 0.992, 0.992, 0.855, 0.741, 0.741, 0.847, 0.992, 0.992, 0.992, 0.643, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.282, 0.878, 0.992, 0.996, 0.992, 0.992, 0.992, 0.984, 0.557, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.58, 0.902, 0.992, 0.831, 0.51, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.302, 0.992, 0.992, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.373, 0.925, 0.988, 0.988, 0.729, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.788, 0.988, 0.988, 0.988, 0.761, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.773, 0.992, 0.988, 0.957, 0.518, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.42, 0.988, 0.992, 0.918, 0.31, 0.141, 0.294, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.941, 0.988, 0.988, 0.945, 0.322, 0.114, 0.835, 0.988, 0.698, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.769, 0.988, 0.988, 0.988, 0.275, 0.0, 0.643, 0.988, 0.988, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.106, 0.769, 0.988, 0.988, 0.988, 0.78, 0.0, 0.0, 0.643, 0.988, 0.988, 0.839, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.827, 0.988, 0.988, 0.988, 0.851, 0.094, 0.0, 0.0, 0.643, 0.988, 0.988, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.988, 0.988, 0.988, 0.988, 0.812, 0.0, 0.0, 0.0, 0.643, 0.988, 0.988, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.945, 0.992, 0.992, 0.992, 0.992, 0.992, 1.0, 0.855, 0.788, 0.992, 0.992, 0.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.584, 0.753, 0.973, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.988, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.329, 0.451, 0.929, 0.933, 0.929, 0.965, 0.988, 0.988, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.988, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.988, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.988, 0.29, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.831, 0.137, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.796, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.988, 0.761, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.678, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.4, 0.161, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.282, 0.596, 0.996, 0.992, 0.082, 0.0, 0.918, 0.992, 0.918, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.718, 0.992, 0.988, 0.992, 0.988, 0.4, 0.0, 0.118, 0.831, 0.992, 0.514, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.518, 0.996, 0.992, 0.996, 0.835, 0.918, 0.992, 0.482, 0.0, 0.0, 0.161, 1.0, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.914, 0.988, 0.992, 0.988, 0.675, 0.039, 0.439, 0.831, 0.0, 0.0, 0.0, 0.0, 0.835, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.839, 0.992, 0.996, 0.914, 0.718, 0.078, 0.0, 0.0, 0.243, 0.239, 0.0, 0.0, 0.0, 0.0, 0.996, 0.675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.796, 0.992, 0.988, 0.357, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.675, 0.831, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.518, 0.992, 0.957, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.557, 0.992, 0.988, 0.635, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.992, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.914, 0.996, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.914, 0.996, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.988, 0.835, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.835, 0.988, 0.753, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.992, 0.639, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.282, 0.757, 0.996, 0.914, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.914, 0.988, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.796, 0.992, 0.988, 0.753, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.282, 0.596, 0.996, 0.992, 0.957, 0.635, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.675, 0.988, 0.875, 0.478, 0.082, 0.078, 0.4, 0.557, 0.796, 0.796, 0.992, 0.988, 0.992, 0.831, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.875, 1.0, 0.992, 1.0, 0.992, 0.996, 0.992, 0.996, 0.992, 0.957, 0.635, 0.161, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.439, 0.753, 0.992, 0.988, 0.914, 0.592, 0.592, 0.275, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.357, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.337, 0.745, 0.992, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.337, 0.992, 0.992, 0.992, 0.796, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.929, 0.992, 0.992, 0.992, 0.714, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.357, 0.992, 0.992, 0.992, 0.757, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.898, 0.992, 0.992, 0.965, 0.412, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.992, 0.863, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.882, 0.224, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.196, 0.259, 0.259, 0.259, 0.675, 0.259, 0.259, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.992, 0.573, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.894, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.573, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.529, 0.965, 0.976, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.976, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.573, 0.0, 0.0, 0.0, 0.02, 0.2, 0.871, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.973, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.737, 0.086, 0.0, 0.0, 0.545, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.992, 0.992, 0.71, 0.051, 0.0, 0.545, 0.992, 0.992, 0.961, 0.459, 0.255, 0.255, 0.298, 0.871, 0.992, 0.992, 0.992, 0.714, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.357, 0.992, 0.992, 0.992, 0.729, 0.455, 0.749, 0.992, 0.992, 0.671, 0.0, 0.0, 0.337, 0.694, 0.992, 0.992, 0.89, 0.541, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.761, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.929, 0.804, 0.804, 0.945, 0.992, 0.992, 0.992, 0.247, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.376, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.906, 0.478, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.125, 0.651, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.824, 0.765, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.416, 0.902, 0.992, 0.992, 0.992, 0.992, 0.973, 0.416, 0.106, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.416, 0.286, 0.306, 0.059, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.102, 0.275, 0.667, 0.996, 0.996, 0.996, 0.796, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.643, 0.937, 0.996, 0.992, 0.992, 0.992, 0.996, 0.992, 0.918, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.518, 0.992, 0.992, 0.996, 0.91, 0.902, 0.902, 0.773, 0.984, 0.992, 0.925, 0.169, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.133, 0.667, 0.992, 0.992, 0.992, 0.404, 0.024, 0.0, 0.0, 0.0, 0.506, 0.992, 0.992, 0.624, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.592, 1.0, 0.847, 0.525, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.816, 0.996, 0.498, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.871, 0.847, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.992, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.443, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.992, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.992, 0.231, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38, 0.996, 0.663, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.922, 0.973, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.733, 0.992, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.592, 0.996, 0.78, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.969, 0.996, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.569, 0.992, 0.608, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.992, 0.992, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.643, 0.969, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.984, 0.902, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.992, 0.933, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.925, 0.212, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.255, 0.973, 1.0, 0.675, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.231, 0.569, 0.929, 0.988, 0.988, 0.992, 0.988, 0.643, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.212, 0.616, 0.882, 0.988, 0.988, 0.988, 0.988, 0.988, 0.992, 0.988, 0.933, 0.204, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.494, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.812, 0.988, 0.988, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.569, 0.282, 0.051, 0.988, 0.988, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.988, 0.988, 0.988, 0.988, 0.757, 0.298, 0.024, 0.0, 0.051, 0.988, 0.988, 0.467, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.608, 0.988, 0.988, 0.925, 0.655, 0.298, 0.035, 0.0, 0.0, 0.0, 0.435, 0.988, 0.988, 0.416, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.365, 0.141, 0.114, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.702, 0.988, 0.988, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.992, 0.988, 0.925, 0.188, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.992, 0.988, 0.847, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.227, 0.745, 1.0, 0.992, 0.827, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.988, 0.992, 0.98, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.91, 0.988, 0.992, 0.906, 0.145, 0.145, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.157, 0.722, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.639, 0.192, 0.192, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.239, 0.376, 0.937, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.882, 0.506, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.11, 0.8, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.525, 0.988, 0.988, 0.988, 0.988, 0.988, 0.988, 0.831, 0.188, 0.188, 0.188, 0.188, 0.188, 0.322, 0.655, 0.655, 0.957, 0.514, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.212, 0.988, 0.988, 0.988, 0.988, 0.988, 0.824, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.145, 0.988, 0.988, 0.988, 0.988, 0.62, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.675, 0.988, 0.851, 0.361, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.094, 0.094, 0.094, 0.094, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.471, 0.729, 0.988, 0.988, 0.992, 0.988, 0.769, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.643, 0.722, 0.992, 0.988, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.176, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.722, 0.988, 0.988, 0.992, 0.988, 0.988, 0.69, 0.627, 0.827, 0.988, 0.988, 0.176, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.722, 0.988, 0.988, 0.537, 0.251, 0.086, 0.016, 0.0, 0.541, 0.988, 0.988, 0.176, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.29, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.584, 0.992, 0.992, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.992, 0.988, 0.816, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.902, 0.992, 0.941, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.133, 0.933, 0.992, 0.808, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.855, 0.988, 0.992, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.541, 0.992, 0.992, 0.659, 0.0, 0.0, 0.0, 0.0, 0.012, 0.051, 0.094, 0.094, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.988, 0.988, 0.906, 0.165, 0.0, 0.0, 0.0, 0.0, 0.667, 0.827, 0.988, 0.988, 0.827, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.722, 0.725, 0.894, 0.988, 0.988, 0.212, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.988, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.957, 0.988, 0.992, 0.988, 0.988, 0.69, 0.016, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.988, 0.988, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.533, 0.965, 0.988, 0.988, 0.992, 0.988, 0.988, 0.957, 0.494, 0.455, 0.455, 0.78, 0.902, 0.98, 0.992, 0.988, 0.988, 0.824, 0.333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.341, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.992, 0.992, 0.992, 0.988, 0.902, 0.451, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.831, 0.988, 0.988, 0.988, 0.906, 0.812, 0.925, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.839, 0.6, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.988, 0.89, 0.188, 0.0, 0.173, 0.392, 0.718, 0.718, 0.478, 0.271, 0.271, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.627, 0.502, 0.114, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.58, 0.69, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 1.0, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.996, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.8, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.839, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.996, 0.553, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.89, 0.553, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.718, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.463, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.741, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.839, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.769, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.345, 0.835, 0.071, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.604, 0.992, 0.753, 0.184, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.988, 0.988, 0.992, 0.427, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.918, 0.988, 0.992, 0.427, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38, 0.988, 0.992, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.576, 0.992, 1.0, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.82, 0.988, 0.918, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.988, 0.988, 0.733, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.988, 0.988, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.992, 0.992, 0.745, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.988, 0.988, 0.255, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.729, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.447, 0.996, 0.969, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.761, 0.992, 0.769, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.333, 0.988, 0.992, 0.427, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.333, 0.988, 0.945, 0.184, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.384, 0.992, 0.639, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.773, 0.988, 0.737, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.176, 0.941, 0.988, 0.882, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.6, 0.988, 0.882, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 0.902, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.129, 0.945, 0.996, 0.286, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.557, 0.996, 0.98, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.996, 0.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.988, 0.996, 0.831, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.796, 0.996, 1.0, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.89, 0.996, 0.69, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.612, 0.996, 0.996, 0.549, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.937, 0.996, 0.753, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.996, 0.996, 0.427, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.965, 0.996, 0.996, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.996, 0.996, 0.384, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.914, 0.996, 0.925, 0.133, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.996, 0.988, 0.204, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.8, 0.996, 0.851, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.996, 0.976, 0.357, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.694, 0.996, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.694, 0.996, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.694, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.525, 0.694, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.49, 0.49, 0.49, 0.631, 0.996, 0.996, 0.996, 1.0, 0.996, 0.996, 0.945, 0.451, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.929, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.424, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.949, 0.992, 0.992, 0.992, 0.992, 0.882, 0.557, 0.557, 0.557, 0.851, 0.992, 0.992, 0.992, 0.431, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.267, 0.941, 0.643, 0.584, 0.176, 0.055, 0.0, 0.0, 0.0, 0.051, 0.663, 0.992, 0.992, 0.431, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.725, 0.957, 0.992, 0.922, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.361, 0.361, 0.361, 0.725, 0.89, 0.992, 0.992, 0.992, 0.471, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.129, 0.518, 0.843, 0.89, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.776, 0.345, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.388, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.549, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.647, 0.949, 0.906, 0.937, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.973, 0.471, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.192, 0.157, 0.18, 0.227, 0.227, 0.592, 0.737, 0.91, 0.992, 0.992, 0.976, 0.467, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.169, 0.608, 0.992, 0.992, 0.98, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.718, 0.992, 0.992, 0.824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.18, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.259, 0.992, 0.992, 0.969, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.988, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.929, 0.992, 0.973, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.129, 0.639, 0.992, 0.91, 0.173, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.682, 0.992, 0.827, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.482, 0.992, 0.992, 0.988, 0.412, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.451, 0.992, 0.992, 0.827, 0.588, 0.141, 0.078, 0.078, 0.078, 0.078, 0.078, 0.078, 0.435, 0.651, 0.992, 0.992, 0.988, 0.604, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.945, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.988, 0.604, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.212, 0.459, 0.929, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.988, 0.969, 0.604, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.435, 0.482, 0.482, 0.639, 0.729, 0.992, 0.608, 0.482, 0.482, 0.408, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.682, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.18, 0.494, 0.306, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.224, 0.71, 0.996, 0.733, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.639, 0.996, 0.769, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.247, 0.361, 0.769, 0.996, 0.996, 0.996, 0.733, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.506, 0.996, 0.957, 0.478, 0.227, 0.4, 0.604, 0.604, 0.914, 0.992, 0.996, 0.988, 0.773, 0.89, 0.996, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.604, 0.984, 0.996, 0.996, 0.996, 0.996, 0.98, 0.902, 0.902, 0.553, 0.224, 0.0, 0.529, 0.945, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.282, 0.282, 0.282, 0.282, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.659, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.906, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.129, 0.949, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.408, 0.996, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.996, 0.58, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.498, 0.996, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.541, 0.996, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.847, 0.859, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42, 0.996, 0.675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42, 0.996, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 0.996, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.133, 0.953, 0.776, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.996, 0.714, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 0.996, 0.714, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.173, 0.996, 0.569, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.173, 0.392, 0.604, 0.737, 0.878, 0.592, 0.082, 0.0, 0.0, 0.086, 0.29, 0.392, 0.604, 0.737, 0.878, 0.89, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.863, 0.996, 0.851, 0.612, 0.584, 0.584, 0.878, 0.773, 0.541, 0.729, 0.957, 0.898, 0.62, 0.584, 0.365, 0.235, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.702, 0.733, 0.114, 0.012, 0.0, 0.282, 0.714, 0.976, 0.808, 0.62, 0.369, 0.122, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.498, 0.953, 0.388, 0.467, 0.714, 0.957, 0.612, 0.192, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.843, 1.0, 0.996, 0.416, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.776, 0.831, 0.396, 0.89, 0.655, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.588, 0.902, 0.145, 0.0, 0.2, 0.949, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.894, 0.506, 0.0, 0.0, 0.0, 0.651, 0.827, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.894, 0.835, 0.525, 0.584, 0.675, 0.965, 0.392, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.588, 0.875, 0.851, 0.631, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.184, 0.192, 0.588, 0.588, 0.588, 0.757, 0.808, 0.996, 1.0, 0.89, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.369, 0.573, 0.773, 0.788, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.314, 0.992, 0.992, 0.992, 0.992, 0.902, 0.851, 0.851, 0.851, 0.851, 0.71, 0.827, 0.557, 0.882, 0.992, 0.545, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.667, 0.294, 0.263, 0.263, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.992, 0.545, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.992, 0.545, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.773, 0.992, 0.431, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.894, 0.992, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.922, 0.992, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.992, 0.761, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.886, 0.992, 0.325, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.992, 0.961, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.992, 0.678, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.937, 0.992, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38, 0.992, 0.957, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.753, 0.957, 0.314, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.349, 0.969, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.992, 0.596, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.976, 0.98, 0.114, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.388, 0.992, 0.647, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.922, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.314, 0.812, 1.0, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.992, 0.992, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.243, 0.839, 0.992, 0.992, 0.992, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.553, 0.992, 0.992, 0.992, 0.992, 0.992, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.882, 0.992, 0.992, 0.992, 0.867, 0.58, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.765, 0.992, 0.992, 0.992, 0.788, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.314, 0.992, 0.992, 0.992, 0.835, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.992, 0.204, 0.0, 0.302, 0.416, 0.416, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.639, 0.157, 0.722, 0.918, 0.992, 0.992, 0.918, 0.722, 0.102, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.51, 0.792, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.655, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.51, 0.792, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.62, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.643, 0.627, 0.831, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.988, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.992, 0.204, 0.173, 0.831, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.541, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.929, 0.992, 0.992, 0.992, 0.914, 0.608, 0.278, 0.235, 0.098, 0.098, 0.624, 0.992, 0.992, 0.992, 0.541, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.569, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.827, 0.514, 0.376, 0.584, 0.992, 0.992, 0.992, 0.776, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.545, 0.973, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.945, 0.922, 0.992, 0.992, 0.992, 0.992, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.235, 0.784, 0.949, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.647, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.259, 0.612, 0.612, 0.863, 0.729, 0.992, 0.992, 0.992, 0.937, 0.337, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.204, 0.094, 0.71, 0.373, 0.306, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.443, 0.757, 0.996, 0.992, 0.996, 0.992, 0.996, 0.675, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.718, 0.992, 0.988, 0.992, 0.988, 0.992, 0.988, 0.992, 0.988, 0.953, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.796, 1.0, 0.914, 0.718, 0.4, 0.796, 0.796, 0.918, 0.992, 0.996, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.318, 0.592, 0.196, 0.0, 0.0, 0.0, 0.161, 0.757, 0.988, 0.992, 0.435, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.835, 0.996, 0.992, 0.796, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.835, 0.988, 0.992, 0.988, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.992, 0.996, 0.992, 0.996, 0.592, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.831, 0.992, 0.988, 0.992, 0.91, 0.875, 0.478, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.875, 0.996, 0.992, 0.996, 0.992, 0.996, 0.278, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.196, 0.514, 0.835, 0.988, 0.992, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.635, 0.996, 0.992, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.796, 0.992, 0.988, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.992, 0.996, 0.357, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.557, 0.992, 0.988, 0.914, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.839, 0.992, 0.996, 0.835, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.639, 0.953, 0.992, 0.988, 0.675, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.678, 0.678, 0.992, 1.0, 0.992, 0.878, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.988, 0.992, 0.988, 0.992, 0.671, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.992, 0.957, 0.796, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.753, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.204, 0.027, 0.365, 0.514, 0.514, 0.514, 0.753, 0.514, 0.922, 0.824, 0.514, 0.314, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.82, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.984, 0.949, 0.949, 0.973, 0.992, 0.996, 0.58, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.733, 0.937, 0.949, 0.827, 0.439, 0.439, 0.439, 0.31, 0.0, 0.0, 0.216, 0.604, 0.996, 0.749, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.996, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.286, 0.953, 0.996, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.878, 0.996, 0.937, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.055, 0.694, 0.996, 0.996, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.455, 0.996, 0.996, 0.922, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.404, 0.996, 0.996, 0.918, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.941, 0.996, 0.996, 0.51, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.188, 0.941, 0.996, 0.996, 0.369, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.318, 0.835, 0.996, 0.996, 0.604, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22, 0.8, 0.996, 0.996, 0.604, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.227, 0.792, 0.996, 0.996, 0.604, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31, 0.949, 0.996, 0.996, 0.608, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.537, 0.957, 0.996, 0.996, 0.612, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.467, 0.961, 0.996, 0.996, 0.616, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.722, 0.996, 0.996, 0.996, 0.706, 0.176, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.996, 0.996, 0.941, 0.224, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.537, 1.0, 0.949, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.329, 1.0, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.102, 0.984, 0.992, 0.957, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.188, 0.882, 0.812, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.953, 0.992, 0.965, 0.247, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.859, 0.98, 0.235, 0.016, 0.0, 0.0, 0.0, 0.0, 0.067, 0.749, 0.992, 0.992, 0.733, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.671, 0.992, 0.992, 0.439, 0.0, 0.0, 0.0, 0.0, 0.0, 0.353, 0.992, 0.992, 0.965, 0.525, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.62, 0.992, 0.992, 0.875, 0.376, 0.0, 0.0, 0.0, 0.0, 0.0, 0.404, 0.992, 0.992, 0.729, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.439, 0.992, 0.992, 0.992, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.667, 0.992, 0.992, 0.576, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.882, 0.992, 0.992, 0.808, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.569, 0.937, 0.992, 0.91, 0.165, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.984, 0.992, 0.992, 0.992, 0.824, 0.373, 0.204, 0.0, 0.0, 0.204, 0.776, 0.992, 0.957, 0.376, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.957, 0.992, 0.992, 0.992, 0.992, 0.992, 0.929, 0.769, 0.388, 0.788, 0.992, 0.992, 0.929, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.467, 0.761, 0.851, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.486, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.11, 0.278, 0.71, 0.788, 0.847, 0.992, 0.992, 0.992, 0.992, 0.882, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.573, 0.992, 0.992, 0.992, 0.745, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.686, 0.992, 0.992, 0.875, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.702, 0.992, 0.992, 0.486, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.792, 0.992, 0.973, 0.275, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.137, 0.878, 0.992, 0.894, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.282, 0.992, 0.992, 0.8, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.988, 0.992, 0.882, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.882, 0.875, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.2, 0.518, 0.596, 0.596, 0.757, 0.914, 0.996, 0.675, 0.757, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.4, 0.718, 0.796, 0.875, 0.992, 0.988, 0.992, 0.988, 0.992, 0.988, 0.992, 0.988, 0.992, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.992, 0.996, 0.992, 0.996, 0.992, 0.996, 0.992, 0.996, 0.914, 0.796, 0.796, 0.918, 0.992, 1.0, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.592, 0.592, 0.592, 0.592, 0.357, 0.196, 0.196, 0.118, 0.0, 0.0, 0.439, 0.988, 0.992, 0.435, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.839, 0.992, 1.0, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.992, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.996, 0.992, 0.718, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.718, 0.992, 0.988, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.992, 0.996, 0.992, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.988, 0.992, 0.831, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.839, 0.992, 0.996, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.4, 0.992, 0.988, 0.914, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.835, 0.996, 0.992, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.596, 0.988, 0.992, 0.831, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.996, 0.992, 0.957, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.875, 0.992, 0.988, 0.635, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.992, 0.996, 0.753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.992, 0.988, 0.914, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.718, 0.996, 0.992, 0.322, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.078, 0.992, 0.671, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.929, 0.369, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.992, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.925, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.314, 0.992, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.545, 0.996, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.871, 0.992, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.902, 0.992, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.902, 0.992, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.906, 0.969, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.953, 0.702, 0.0, 0.0, 0.0, 0.0, 0.067, 0.545, 0.541, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.306, 0.992, 0.537, 0.0, 0.0, 0.02, 0.553, 0.878, 0.969, 0.984, 0.941, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.992, 0.537, 0.0, 0.0, 0.576, 0.992, 0.859, 0.329, 0.639, 0.992, 0.404, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.635, 0.996, 0.541, 0.0, 0.6, 0.996, 0.608, 0.098, 0.0, 0.545, 0.996, 0.631, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.992, 0.537, 0.525, 0.945, 0.545, 0.016, 0.0, 0.0, 0.741, 0.992, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.992, 0.537, 0.722, 0.69, 0.0, 0.0, 0.0, 0.224, 0.976, 0.918, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.992, 0.573, 0.82, 0.365, 0.0, 0.0, 0.0, 0.667, 0.992, 0.635, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.973, 0.937, 0.725, 0.365, 0.0, 0.027, 0.408, 1.0, 0.878, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.902, 0.984, 0.412, 0.035, 0.169, 0.651, 0.992, 0.945, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.976, 0.992, 0.816, 0.976, 0.992, 0.957, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.992, 0.996, 0.659, 0.467, 0.173, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.898, 0.392, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.765, 0.996, 0.988, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.2, 0.847, 0.996, 0.89, 0.275, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.804, 0.996, 0.996, 0.267, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.196, 0.969, 0.996, 0.667, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.553, 0.906, 0.988, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.486, 0.996, 0.992, 0.333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.067, 0.431, 0.996, 0.996, 0.533, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.635, 0.973, 0.996, 0.549, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.435, 0.988, 0.996, 0.686, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.8, 0.996, 0.871, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.773, 0.996, 0.878, 0.149, 0.0, 0.0, 0.0, 0.0, 0.286, 0.424, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.157, 0.639, 0.996, 0.894, 0.141, 0.0, 0.0, 0.0, 0.145, 0.604, 0.988, 0.996, 0.953, 0.145, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.624, 0.996, 0.996, 0.373, 0.0, 0.0, 0.0, 0.271, 0.906, 0.996, 0.996, 0.996, 0.996, 0.541, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.996, 0.894, 0.255, 0.004, 0.0, 0.0, 0.216, 0.992, 0.996, 0.996, 0.996, 0.996, 0.996, 0.204, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.302, 0.957, 0.949, 0.271, 0.0, 0.0, 0.0, 0.298, 0.894, 0.996, 0.996, 0.996, 0.996, 0.878, 0.431, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.553, 0.976, 0.643, 0.0, 0.0, 0.0, 0.231, 0.89, 0.996, 0.996, 0.996, 0.949, 0.286, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.698, 0.922, 0.369, 0.416, 0.467, 0.463, 0.839, 0.996, 0.996, 0.953, 0.894, 0.49, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.792, 0.996, 0.996, 0.996, 0.996, 0.961, 0.827, 0.365, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.494, 0.996, 0.863, 0.647, 0.647, 0.114, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.306, 0.765, 0.878, 1.0, 0.984, 0.447, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.502, 0.988, 0.988, 0.769, 0.502, 0.518, 0.922, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.29, 0.753, 0.996, 0.925, 0.318, 0.0, 0.0, 0.0, 0.282, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.486, 0.988, 0.976, 0.502, 0.035, 0.0, 0.0, 0.0, 0.0, 0.173, 0.545, 0.137, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.592, 0.996, 0.894, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.494, 0.996, 0.596, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.165, 0.953, 0.878, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.416, 0.996, 0.996, 0.596, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.588, 0.996, 0.655, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.18, 0.898, 0.996, 0.996, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.996, 0.655, 0.0, 0.0, 0.0, 0.0, 0.0, 0.31, 0.894, 0.965, 0.996, 0.984, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.267, 0.945, 0.894, 0.412, 0.0, 0.0, 0.0, 0.286, 0.898, 0.753, 0.478, 0.996, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.941, 0.984, 0.769, 0.565, 0.565, 0.914, 0.867, 0.224, 0.627, 0.996, 0.773, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.78, 0.937, 0.937, 0.937, 0.753, 0.063, 0.075, 0.878, 0.996, 0.447, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.286, 0.996, 0.91, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.545, 0.996, 0.71, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.847, 0.996, 0.553, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.996, 0.984, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.996, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.804, 0.996, 0.431, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.996, 0.996, 0.204, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.996, 0.996, 0.537, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.753, 0.996, 0.439, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.165, 0.388, 0.992, 0.486, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.569, 0.808, 0.984, 0.984, 0.984, 0.871, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.145, 0.992, 0.984, 0.984, 0.984, 0.984, 0.992, 0.42, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.667, 0.984, 0.992, 0.984, 0.984, 0.984, 0.984, 0.992, 0.663, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.984, 0.984, 0.992, 0.984, 0.984, 0.984, 0.984, 0.992, 0.984, 0.643, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.286, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.137, 0.0, 0.714, 1.0, 0.992, 0.992, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.69, 0.984, 0.984, 0.984, 0.984, 0.992, 0.659, 0.059, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.651, 0.992, 0.984, 0.984, 0.984, 0.882, 0.643, 0.059, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.984, 0.992, 0.984, 0.984, 0.8, 0.161, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.612, 0.827, 0.984, 0.992, 0.984, 0.882, 0.161, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.165, 0.894, 0.992, 0.992, 1.0, 0.992, 0.643, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.714, 1.0, 0.992, 0.992, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.565, 0.984, 0.984, 0.984, 0.992, 0.659, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.565, 0.984, 0.984, 0.984, 0.745, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.565, 0.984, 0.984, 0.984, 0.706, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.565, 0.984, 0.984, 0.984, 0.706, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.412, 0.953, 0.992, 0.992, 1.0, 0.584, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.714, 1.0, 0.992, 0.992, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.663, 0.984, 0.992, 0.984, 0.925, 0.565, 0.565, 0.412, 0.0, 0.0, 0.0, 0.706, 0.992, 0.984, 0.984, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.843, 0.992, 0.984, 0.984, 0.984, 0.984, 0.953, 0.851, 0.851, 0.851, 0.945, 0.992, 0.984, 0.965, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.686, 0.984, 0.984, 0.984, 0.984, 0.992, 0.984, 0.984, 0.984, 0.984, 0.992, 0.984, 0.537, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.082, 0.278, 0.38, 0.984, 0.984, 0.992, 0.984, 0.984, 0.984, 0.478, 0.282, 0.278, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.502, 1.0, 1.0, 0.502, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 1.0, 0.749, 1.0, 1.0, 0.502, 0.502, 0.502, 0.502, 0.502, 0.749, 1.0, 1.0, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.749, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.749, 1.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 0.749, 0.251, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.749, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.502, 0.502, 1.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.141, 0.945, 0.212, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 0.992, 0.212, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.298, 0.192, 0.0, 0.0, 0.0, 0.0, 0.0, 0.196, 0.957, 0.969, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.788, 0.992, 0.788, 0.027, 0.0, 0.0, 0.0, 0.0, 0.792, 0.992, 0.824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.635, 0.992, 0.992, 0.357, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.996, 0.894, 0.0, 0.0, 0.0, 0.024, 0.667, 1.0, 0.753, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.404, 0.98, 0.992, 0.435, 0.0, 0.0, 0.0, 0.149, 0.992, 0.996, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.906, 0.992, 0.573, 0.043, 0.0, 0.0, 0.125, 0.835, 0.992, 0.698, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.329, 0.996, 0.992, 0.702, 0.047, 0.0, 0.047, 0.353, 0.886, 0.992, 0.965, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.18, 0.757, 0.992, 0.996, 0.459, 0.043, 0.31, 0.71, 0.894, 0.992, 0.992, 0.965, 0.282, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.141, 0.945, 0.996, 0.996, 1.0, 0.996, 0.996, 0.996, 0.996, 1.0, 0.996, 0.996, 0.694, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.298, 0.961, 0.992, 0.992, 0.996, 0.992, 0.882, 0.753, 0.424, 0.792, 0.992, 0.91, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.294, 0.498, 0.271, 0.141, 0.071, 0.0, 0.055, 0.945, 0.961, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.525, 0.996, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.992, 0.894, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.043, 0.843, 0.996, 0.259, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.992, 0.584, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.922, 0.906, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.569, 0.992, 0.416, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.569, 0.941, 0.137, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.561, 0.996, 0.996, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.235, 0.569, 0.353, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.098, 0.624, 0.992, 0.992, 0.475, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.204, 0.961, 0.992, 0.851, 0.125, 0.0, 0.0, 0.0, 0.0, 0.027, 0.573, 0.992, 0.992, 0.992, 0.933, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.804, 0.992, 0.992, 0.851, 0.031, 0.094, 0.02, 0.192, 0.569, 0.992, 0.992, 0.992, 0.922, 0.231, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.714, 0.992, 0.992, 0.992, 0.725, 0.851, 0.737, 0.992, 0.992, 0.992, 0.992, 0.914, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.49, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.925, 0.345, 0.157, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.914, 0.992, 0.992, 0.992, 0.992, 0.996, 0.961, 0.659, 0.345, 0.145, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.094, 0.851, 0.992, 0.847, 0.412, 0.141, 0.141, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.992, 0.992, 0.776, 0.631, 0.675, 0.455, 0.859, 0.431, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.467, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.984, 0.949, 0.224, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.459, 0.988, 0.996, 0.996, 0.976, 0.949, 0.957, 0.949, 0.949, 0.961, 0.996, 0.996, 0.455, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.463, 0.898, 0.49, 0.243, 0.0, 0.0, 0.0, 0.0, 0.082, 0.788, 0.992, 0.992, 0.184, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.847, 0.992, 0.851, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.129, 0.529, 0.918, 0.992, 0.737, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.376, 0.714, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.745, 0.992, 0.992, 0.992, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.886, 0.992, 0.961, 0.443, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.333, 0.792, 0.992, 0.992, 0.992, 0.376, 0.145, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.227, 0.992, 0.992, 0.992, 0.859, 0.808, 0.647, 0.337, 0.192, 0.322, 0.459, 0.992, 0.992, 0.992, 0.992, 0.737, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.184, 0.851, 0.992, 0.992, 0.992, 0.992, 0.992, 0.933, 0.988, 0.996, 0.992, 0.992, 0.992, 0.608, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.494, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.616, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.388, 0.882, 0.992, 0.992, 0.992, 0.992, 0.749, 0.475, 0.043, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.494, 1.0, 0.894, 0.553, 0.553, 0.553, 0.553, 0.553, 0.357, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.894, 0.988, 0.988, 0.988, 0.992, 0.988, 0.988, 0.988, 0.737, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.22, 0.561, 0.463, 0.22, 0.22, 0.561, 0.804, 0.969, 0.259, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.992, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.447, 0.886, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.447, 0.996, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.906, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.737, 0.918, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.992, 0.745, 0.075, 0.0, 0.0, 0.0, 0.263, 0.965, 0.882, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.796, 0.988, 0.757, 0.247, 0.0, 0.0, 0.725, 0.988, 0.49, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.541, 0.922, 0.992, 0.753, 0.259, 0.8, 0.992, 0.396, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.11, 0.522, 0.992, 0.988, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.306, 0.988, 0.988, 0.988, 0.725, 0.333, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.988, 0.988, 0.988, 0.992, 0.988, 0.757, 0.247, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.992, 0.992, 0.306, 0.494, 0.906, 0.992, 0.796, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.988, 0.988, 0.11, 0.0, 0.075, 0.843, 0.988, 0.443, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.988, 0.988, 0.11, 0.0, 0.0, 0.576, 0.988, 0.639, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.988, 0.988, 0.11, 0.0, 0.0, 0.773, 0.988, 0.247, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.114, 0.992, 0.992, 0.157, 0.0, 0.176, 0.898, 0.745, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.769, 0.988, 0.647, 0.275, 0.882, 0.988, 0.451, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.247, 0.918, 0.988, 0.992, 0.988, 0.58, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.941, 0.992, 0.694, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.165, 0.184, 0.361, 0.839, 1.0, 0.765, 0.898, 0.376, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.773, 0.969, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.969, 0.373, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.529, 0.957, 0.976, 0.992, 0.992, 0.992, 0.933, 0.851, 0.851, 0.851, 0.961, 0.992, 0.812, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.992, 0.992, 0.992, 0.706, 0.404, 0.149, 0.0, 0.0, 0.0, 0.753, 0.992, 0.686, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.992, 0.859, 0.369, 0.012, 0.0, 0.0, 0.0, 0.0, 0.02, 0.776, 0.941, 0.455, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.169, 0.306, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.729, 0.992, 0.467, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.627, 0.992, 0.973, 0.106, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.282, 0.863, 0.992, 0.992, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.773, 0.992, 0.992, 0.341, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.498, 0.992, 0.953, 0.631, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.345, 0.784, 0.992, 0.631, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.686, 0.992, 0.992, 0.741, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.58, 0.992, 0.992, 0.992, 0.89, 0.753, 0.753, 0.753, 0.753, 0.537, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.345, 0.847, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.953, 0.702, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.624, 0.984, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.918, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.918, 0.992, 0.992, 0.992, 0.992, 0.992, 0.922, 0.643, 0.333, 0.098, 0.098, 0.098, 0.408, 0.506, 0.824, 0.992, 0.992, 0.933, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.992, 0.992, 0.906, 0.686, 0.325, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.102, 0.38, 0.992, 0.992, 0.698, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.98, 0.671, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.357, 0.988, 0.992, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.369, 0.231, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.855, 0.992, 0.584, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.855, 0.992, 0.424, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.992, 0.918, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.439, 0.91, 0.992, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.796, 0.996, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.796, 0.992, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.796, 0.996, 0.196, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.953, 0.914, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.992, 0.878, 0.078, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.518, 0.988, 0.796, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.596, 0.992, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.757, 0.988, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.557, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.518, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.992, 0.514, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.992, 1.0, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.835, 0.988, 0.992, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.361, 0.992, 1.0, 0.592, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.831, 0.992, 0.275, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.502, 1.0, 1.0, 1.0, 0.749, 0.502, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.502, 0.251, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 0.502, 0.251, 0.749, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 0.749, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 1.0, 1.0, 1.0, 0.502, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.749, 1.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.502, 0.749, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.251, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 1.0, 1.0, 0.749, 0.502, 0.0, 0.0, 0.0, 0.0, 0.251, 0.749, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.749, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.251, 0.502, 1.0, 0.749, 0.749, 0.502, 0.502, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.667, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.827, 0.859, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.996, 0.965, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.996, 0.835, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.024, 0.996, 0.835, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.439, 0.996, 0.639, 0.0, 0.0, 0.0, 0.0, 0.024, 0.424, 0.149, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.957, 0.996, 0.361, 0.0, 0.0, 0.0, 0.0, 0.059, 0.996, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.467, 0.996, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.773, 0.996, 0.604, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.957, 0.976, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.98, 0.996, 0.812, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.675, 0.996, 0.537, 0.0, 0.0, 0.0, 0.0, 0.0, 0.314, 0.992, 1.0, 0.486, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.871, 0.675, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.447, 0.996, 0.996, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.671, 0.996, 0.929, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.447, 0.996, 0.996, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.745, 0.996, 0.996, 0.996, 0.91, 0.831, 0.447, 0.584, 0.91, 0.949, 0.996, 0.996, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.145, 0.647, 0.953, 0.953, 0.996, 0.996, 0.996, 0.996, 0.98, 0.953, 0.996, 0.996, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.42, 0.42, 0.42, 0.42, 0.263, 0.0, 0.98, 1.0, 0.404, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.675, 0.996, 0.812, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.996, 0.859, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.996, 0.937, 0.188, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.996, 0.812, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.298, 0.725, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.424, 0.906, 1.0, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.067, 0.725, 0.98, 0.992, 0.996, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.827, 0.992, 0.992, 0.992, 0.569, 0.165, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.937, 0.992, 0.992, 0.788, 0.161, 0.031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.765, 0.996, 0.992, 0.604, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.624, 0.996, 0.945, 0.557, 0.0, 0.0, 0.09, 0.471, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.439, 0.98, 0.961, 0.557, 0.0, 0.027, 0.494, 0.898, 0.859, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.686, 0.992, 0.494, 0.075, 0.486, 0.78, 0.992, 0.753, 0.118, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.969, 0.847, 0.078, 0.643, 0.992, 0.992, 0.847, 0.106, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.875, 0.957, 0.851, 0.996, 0.992, 0.725, 0.133, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.69, 0.996, 0.996, 1.0, 0.741, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.945, 0.992, 0.992, 0.8, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.886, 0.992, 0.992, 0.992, 0.835, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.788, 0.992, 0.992, 0.702, 0.898, 0.996, 0.42, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.529, 0.996, 0.992, 0.604, 0.02, 0.235, 0.996, 0.914, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.996, 1.0, 0.592, 0.0, 0.0, 0.09, 1.0, 0.918, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.886, 0.082, 0.0, 0.102, 0.663, 0.996, 0.737, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.835, 0.31, 0.573, 0.851, 0.992, 0.922, 0.224, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.478, 0.992, 0.996, 0.992, 0.992, 0.992, 0.725, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.522, 0.996, 0.667, 0.608, 0.255, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.624, 0.847, 0.612, 0.439, 0.231, 0.106, 0.09, 0.322, 0.58, 0.071, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.239, 0.973, 0.992, 0.996, 0.992, 0.992, 0.91, 0.898, 0.996, 0.992, 0.306, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.922, 0.682, 0.78, 0.871, 0.753, 0.686, 0.506, 0.094, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.216, 0.992, 0.765, 0.0, 0.024, 0.047, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.992, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.996, 0.769, 0.11, 0.231, 0.439, 0.467, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.533, 0.992, 0.871, 0.851, 0.992, 0.992, 0.992, 0.961, 0.514, 0.196, 0.008, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.8, 0.992, 0.996, 0.992, 0.894, 0.624, 0.451, 0.757, 0.992, 0.992, 0.459, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.918, 0.992, 0.996, 0.506, 0.051, 0.0, 0.0, 0.02, 0.282, 0.945, 0.98, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.624, 0.992, 0.376, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.961, 0.902, 0.149, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.596, 0.996, 0.675, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.886, 0.996, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.118, 0.647, 0.996, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.529, 0.996, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.906, 0.8, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.678, 0.996, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.529, 1.0, 0.886, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.529, 1.0, 0.682, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.357, 0.996, 0.922, 0.459, 0.035, 0.0, 0.0, 0.0, 0.0, 0.102, 0.812, 0.996, 0.357, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.608, 0.992, 0.992, 0.827, 0.396, 0.0, 0.0, 0.098, 0.675, 0.992, 0.835, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.282, 0.886, 0.992, 0.992, 0.922, 0.918, 0.941, 0.992, 0.929, 0.208, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.58, 0.902, 0.996, 0.992, 0.992, 0.784, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.282, 0.961, 0.996, 0.996, 0.996, 0.565, 0.565, 0.733, 0.961, 0.471, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.333, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.992, 0.89, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.992, 0.992, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.98, 0.992, 0.992, 0.675, 0.153, 0.039, 0.043, 0.345, 0.867, 0.992, 0.992, 0.773, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.992, 0.992, 0.992, 0.388, 0.0, 0.0, 0.0, 0.0, 0.137, 0.345, 0.345, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.522, 0.992, 0.992, 0.992, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.502, 0.992, 0.992, 0.992, 0.867, 0.478, 0.478, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.949, 0.608, 0.18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.894, 0.486, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.012, 0.502, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.945, 0.153, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.435, 0.435, 0.173, 0.0, 0.192, 0.494, 0.957, 0.996, 0.996, 0.902, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.51, 0.949, 0.992, 0.992, 0.757, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.467, 0.992, 0.992, 0.992, 0.447, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.537, 0.992, 0.992, 0.933, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.965, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.804, 0.992, 0.992, 0.949, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.992, 0.761, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.463, 0.984, 0.992, 0.992, 0.949, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.376, 0.992, 0.992, 0.929, 0.702, 0.216, 0.047, 0.047, 0.294, 0.592, 0.98, 0.992, 0.992, 0.992, 0.914, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.596, 0.933, 0.992, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.992, 0.992, 0.992, 0.706, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.169, 0.835, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.51, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.102, 0.337, 0.486, 0.451, 0.937, 0.996, 0.992, 0.824, 0.145, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.075, 0.133, 0.133, 0.51, 0.51, 0.435, 0.565, 0.565, 0.847, 0.996, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.267, 0.8, 0.863, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.992, 0.992, 0.949, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.961, 0.604, 0.737, 0.424, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.992, 0.941, 0.773, 0.475, 0.855, 0.475, 0.306, 0.039, 0.0, 0.016, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.584, 0.137, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.071, 0.922, 0.871, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.11, 0.992, 0.647, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.596, 0.992, 0.518, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.824, 0.992, 0.992, 0.757, 0.737, 0.42, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.522, 0.992, 0.992, 0.992, 0.992, 0.992, 0.694, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.745, 0.953, 0.867, 0.867, 0.965, 0.996, 0.945, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.067, 0.196, 0.0, 0.0, 0.357, 0.847, 1.0, 0.914, 0.122, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.075, 0.827, 0.992, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.992, 0.976, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.227, 0.992, 0.737, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.231, 0.227, 0.0, 0.0, 0.0, 0.153, 0.906, 0.992, 0.455, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.29, 0.965, 0.647, 0.0, 0.008, 0.369, 0.89, 0.996, 0.965, 0.165, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.259, 0.992, 0.706, 0.573, 0.675, 0.992, 0.992, 0.976, 0.251, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.89, 0.992, 0.992, 0.992, 0.992, 0.863, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.463, 0.804, 0.992, 0.918, 0.431, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.49, 0.816, 0.996, 0.996, 0.973, 0.478, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.122, 0.463, 0.463, 0.82, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.733, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.494, 0.957, 0.992, 0.992, 0.992, 0.702, 0.557, 0.557, 0.592, 0.992, 0.992, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 0.98, 0.992, 0.992, 0.992, 0.827, 0.027, 0.0, 0.0, 0.047, 0.816, 0.992, 0.69, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.325, 0.894, 0.976, 0.992, 0.992, 0.992, 0.608, 0.082, 0.0, 0.0, 0.0, 0.071, 0.949, 0.992, 0.529, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.325, 0.851, 0.992, 0.992, 0.992, 0.992, 0.604, 0.035, 0.0, 0.0, 0.0, 0.0, 0.078, 0.992, 0.992, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.333, 0.929, 0.992, 0.992, 0.992, 0.992, 0.906, 0.435, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.773, 0.992, 0.745, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.439, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.318, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.345, 0.992, 0.992, 0.482, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.141, 0.78, 0.882, 0.992, 0.992, 0.992, 0.992, 0.992, 0.361, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.992, 0.827, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.616, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.361, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.212, 0.902, 0.98, 0.341, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.886, 0.863, 0.992, 0.992, 0.992, 0.624, 0.047, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.612, 0.992, 0.969, 0.235, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.278, 0.149, 0.804, 0.992, 0.992, 0.627, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.533, 0.886, 0.976, 0.486, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.322, 0.98, 0.992, 0.831, 0.102, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.569, 0.992, 0.992, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.537, 0.992, 0.992, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.306, 0.992, 0.992, 0.898, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.906, 0.992, 0.992, 0.165, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.569, 0.992, 0.992, 0.925, 0.184, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.255, 0.788, 0.992, 0.78, 0.243, 0.0, 0.0, 0.086, 0.251, 0.612, 0.702, 0.992, 0.973, 0.545, 0.38, 0.145, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.973, 0.992, 0.992, 0.431, 0.078, 0.51, 0.922, 0.992, 0.992, 0.992, 0.871, 0.333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.71, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.992, 0.953, 0.824, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.949, 0.98, 0.992, 0.992, 0.992, 0.992, 0.973, 0.557, 0.106, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.212, 0.482, 0.482, 0.482, 0.482, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.71, 0.329, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.651, 0.996, 0.694, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.686, 0.996, 0.996, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.204, 0.965, 0.953, 0.322, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.58, 0.89, 0.996, 0.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.761, 0.996, 0.996, 0.541, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.549, 0.984, 0.996, 0.482, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.427, 0.992, 0.996, 0.996, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.576, 0.996, 0.996, 0.714, 0.027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.169, 0.961, 0.996, 0.859, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.608, 0.996, 0.996, 0.424, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.792, 0.996, 0.996, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.792, 0.996, 0.996, 0.239, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.275, 0.275, 0.275, 0.275, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.792, 0.996, 0.996, 0.286, 0.063, 0.063, 0.435, 0.38, 0.671, 0.698, 0.996, 0.996, 0.996, 0.996, 0.569, 0.063, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.98, 0.263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.141, 0.894, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.925, 0.753, 0.875, 0.996, 0.996, 0.996, 0.996, 0.996, 0.675, 0.043, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.576, 0.996, 0.996, 0.996, 0.996, 0.996, 1.0, 0.89, 0.639, 0.816, 0.996, 0.996, 0.996, 0.996, 0.996, 0.706, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.576, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.969, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.459, 0.784, 0.816, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.984, 0.784, 0.267, 0.173, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.063, 0.392, 0.965, 0.996, 1.0, 0.996, 0.941, 0.392, 0.392, 0.369, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.565, 0.992, 0.506, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.196, 0.918, 0.988, 0.776, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.522, 0.973, 0.988, 0.776, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.533, 0.973, 0.988, 0.988, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.475, 0.988, 0.988, 0.988, 0.988, 0.259, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.859, 0.988, 0.988, 0.922, 0.365, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.992, 0.988, 0.988, 0.675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.816, 0.992, 0.988, 0.988, 0.675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.008, 0.596, 0.988, 0.992, 0.988, 0.988, 0.373, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.384, 0.988, 0.988, 0.992, 0.988, 0.792, 0.075, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.631, 0.992, 0.992, 1.0, 0.792, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.153, 0.969, 0.988, 0.988, 0.792, 0.055, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.627, 0.988, 0.988, 0.988, 0.522, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.345, 0.941, 0.988, 0.988, 0.82, 0.082, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.459, 0.988, 0.988, 0.973, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.196, 0.922, 0.988, 0.988, 0.933, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.651, 0.988, 0.988, 0.988, 0.576, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.318, 0.988, 0.988, 0.988, 0.588, 0.153, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.298, 0.949, 0.988, 0.988, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.467, 0.741, 0.173, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.114, 0.016, 0.408, 0.898, 0.992, 0.506, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.333, 0.988, 0.702, 0.988, 0.988, 0.988, 0.992, 0.478, 0.051, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.482, 0.988, 0.992, 0.988, 0.58, 0.22, 0.992, 0.988, 0.561, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.965, 0.988, 0.992, 0.4, 0.024, 0.0, 0.6, 0.988, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.667, 0.992, 0.992, 1.0, 0.329, 0.0, 0.0, 0.051, 0.812, 0.992, 0.357, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.988, 0.988, 0.969, 0.255, 0.0, 0.0, 0.0, 0.663, 0.988, 0.843, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.988, 0.988, 0.392, 0.0, 0.0, 0.0, 0.0, 0.322, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.102, 0.953, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.161, 0.992, 0.992, 0.992, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.992, 0.992, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.553, 0.988, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.898, 0.988, 0.878, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.988, 0.988, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.996, 0.992, 0.659, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.471, 0.992, 0.745, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.365, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.663, 0.988, 0.255, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.22, 0.0, 0.0, 0.0, 0.0, 0.0, 0.039, 0.773, 0.988, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.992, 0.988, 0.612, 0.0, 0.0, 0.0, 0.0, 0.0, 0.702, 0.988, 0.694, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.702, 0.992, 0.698, 0.063, 0.0, 0.075, 0.259, 0.749, 0.996, 0.82, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.086, 0.918, 0.988, 0.843, 0.663, 0.882, 0.988, 0.988, 0.82, 0.11, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.514, 0.988, 0.988, 0.992, 0.988, 0.988, 0.839, 0.098, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.027, 0.255, 0.941, 0.992, 0.694, 0.404, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.318, 1.0, 0.302, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.976, 0.992, 0.616, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.976, 0.992, 0.871, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.286, 0.988, 0.992, 0.737, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.388, 0.992, 0.992, 0.467, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.671, 0.992, 0.992, 0.467, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.098, 0.886, 0.992, 0.992, 0.275, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.208, 0.992, 0.992, 0.992, 0.059, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.545, 0.992, 0.992, 0.525, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016, 0.847, 0.992, 0.992, 0.243, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.349, 0.992, 0.992, 0.929, 0.149, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.431, 0.992, 0.992, 0.765, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.737, 0.992, 0.992, 0.282, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.184, 0.918, 0.992, 0.992, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.992, 0.875, 0.012, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.031, 0.82, 0.992, 0.992, 0.408, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.173, 0.992, 0.992, 0.855, 0.067, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.651, 0.992, 0.992, 0.773, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.875, 0.992, 0.992, 0.384, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.353, 0.855, 0.984, 0.227, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.816, 0.992, 0.498, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.051, 0.843, 0.988, 0.902, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.988, 0.988, 0.78, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.988, 0.988, 0.824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.988, 0.988, 0.902, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.275, 0.992, 0.992, 0.906, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.224, 0.957, 0.988, 0.902, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.988, 0.902, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.988, 0.902, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.988, 0.945, 0.165, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.816, 0.992, 1.0, 0.361, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.988, 0.992, 0.361, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.812, 0.988, 0.992, 0.686, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.443, 0.988, 0.992, 0.808, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.988, 0.992, 0.89, 0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.992, 1.0, 0.992, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.988, 0.992, 0.988, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.988, 0.992, 0.988, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.365, 0.988, 0.992, 0.988, 0.271, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.035, 0.702, 0.992, 0.616, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.58, 0.996, 0.996, 0.333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.953, 0.992, 0.992, 0.514, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.953, 0.992, 0.992, 0.349, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.376, 0.992, 0.992, 0.659, 0.004, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.392, 0.992, 0.992, 0.549, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.729, 0.992, 0.992, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.906, 0.992, 0.776, 0.02, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.043, 0.035, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.992, 0.992, 0.345, 0.0, 0.0, 0.0, 0.263, 0.608, 0.608, 0.608, 0.776, 0.98, 0.91, 0.459, 0.016, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.992, 0.992, 0.345, 0.0, 0.149, 0.38, 0.929, 0.992, 0.996, 0.992, 0.992, 0.992, 0.992, 0.992, 0.216, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.992, 0.992, 0.345, 0.494, 0.929, 0.992, 0.992, 0.992, 0.996, 0.992, 0.992, 0.992, 0.992, 0.992, 0.894, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.941, 0.816, 0.435, 0.435, 0.435, 0.745, 0.996, 0.996, 0.824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.922, 0.992, 0.992, 0.992, 0.992, 0.949, 0.733, 0.227, 0.0, 0.0, 0.0, 0.0, 0.067, 0.729, 0.992, 0.631, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.263, 0.992, 0.992, 0.992, 0.992, 0.957, 0.141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.349, 0.992, 0.647, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.149, 0.922, 0.992, 0.843, 0.325, 0.039, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.02, 0.592, 0.992, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.09, 0.514, 0.984, 0.627, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22, 0.902, 0.992, 0.388, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.953, 0.949, 0.506, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.373, 0.922, 0.992, 0.62, 0.086, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.745, 0.992, 0.965, 0.498, 0.047, 0.047, 0.047, 0.047, 0.349, 0.835, 0.992, 0.992, 0.98, 0.306, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.243, 0.859, 0.992, 0.992, 0.992, 0.992, 0.992, 1.0, 0.992, 0.992, 0.992, 0.878, 0.345, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.059, 0.702, 0.992, 0.992, 0.992, 0.992, 0.996, 0.992, 0.569, 0.447, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.047, 0.522, 0.561, 0.69, 0.992, 0.561, 0.447, 0.024, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]], "labels": [8, 0, 1, 1, 9, 6, 2, 5, 3, 4, 0, 6, 7, 2, 2, 1, 1, 1, 3, 7, 8, 7, 6, 3, 7, 4, 7, 6, 6, 9, 0, 0, 4, 5, 8, 2, 1, 5, 4, 8, 5, 5, 5, 0, 6, 1, 0, 1, 1, 6]} \ No newline at end of file diff --git a/demos/mnist/softmax_linear_biases b/demos/mnist/softmax_linear_biases new file mode 100644 index 0000000000..eb8fee70f0 --- /dev/null +++ b/demos/mnist/softmax_linear_biases @@ -0,0 +1 @@ +$ý[ >x­®¼’nú½Šr½îù>ÈÃ< >à ¾ñ½ \ No newline at end of file diff --git a/demos/mnist/softmax_linear_weights b/demos/mnist/softmax_linear_weights new file mode 100644 index 0000000000000000000000000000000000000000..3d875142f2ab8e7d89fb507d05d5372fda76fbb9 GIT binary patch literal 1280 zcmWN<3oz7q8~|_>V$>BPDWp<*5D~Ti?{~}HMn-zv7w#_V-=ZlG{pDy7P!p4AOW-$yM&=^GQ8$6=C6Z3a>eZPc*b>Oe>emG`L2UVk0Qb zQgDr*W0}eJH+0jABBSHR+g9W z2)@`HgFVaC**uLSba^<2JH+mSYNwEGwR3~Hyb(6?@B}$F9VXKh3!afrK3MoGU|d)Z zj|RusKx8lt+elC=D+BZ;M^SR11bL9pO6(1!s`YxZo61pCw6=kPB#rRFMYyVEM~R*- z^k$+nrsk^WLX%e$2aA002C@}NIytaPTqueF%+#GfvepT+M>szH78O2)7InO;@@ zuXQ=)yenN_L6k{-lM*A1!`9mlI*@hn(ViL-)$4b)#_|RHDL$UyCtEpxSHmh z%wnXE8g9{xgt5YRkl}8J4iUdVkbw(a2<&4=1C=P>n?>2yUukn(83bP7@n@EmL+sU6 z*yhpzi8VRWr&=p1_`W7Re>cX~XZ}S^)2F%NxL$Cry}^b8)}epQ3%0l11a6D7Ij_ET zy#Dta@Lf?F1SUjaoa8dfE7!<^cCM%8mSH3e_{2_RC*m%t4}ChKhi1=oIIBr5deE_v z$LSctcX0?v%%n9~A^JdngaGuKDc)tS_mT+9YKV_+gB3NBfRD7{O7p;6k{ z9bJe!%M2O6M2}npZ0WSJm`N>7Q2fyX<`q4}$;Z~1$j@NN}qSvY@g~!h0A-UG@UPNbu2}_VLP1MpU<87H!ilGZ@SCWltw#*^aI_=18XuF@)_7>|QI$$HT&ewz0IS$-8Yyc)<;7I!4NAe!@u{#v z&LbPQ0Pyt`(EbE7l0;UK)o3UMPZhxrw`J^EgbLruQ;BOG40xemv~h)5Kh~EHLe~Np zT07J&eUWR5;(`cisNf*`nyz57AB#b3Jq+IFH>pY($%UkbF;V0a+%+PB%u9i6s#d_{ z#+AhDS&A}D!drP^=r?;5bo0`&;B7vIk4@5>U~Mk7;{i2#b#Nam`)T6kHMI1wCEu4e zkTmxosYgbz_^4cz@6=;0hJ{!cunKFdoWUvHka(u{*ff)jrgQq)?!+~8Wmt#6JRD6H qpJ!<`StvTR9h##x+1Yf)!d$jMe1I2tbzf&gxig&RJrTMkq|<*WNPwjP literal 0 HcmV?d00001 diff --git a/demos/model-builder/bundle.js b/demos/model-builder/bundle.js new file mode 100644 index 0000000000..845f76f5e8 --- /dev/null +++ b/demos/model-builder/bundle.js @@ -0,0 +1,9461 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 0) { + var lastLayer = this.hiddenLayers[this.hiddenLayers.length - 1]; + valid = valid && + learnjs_1.util.arraysEqual(this.labelShape, lastLayer.getOutputShape()); + } + this.isValid = valid && (this.hiddenLayers.length > 0); + }; + ModelBuilder.prototype.layerParamChanged = function () { + var lastOutputShape = this.inputShape; + for (var i = 0; i < this.hiddenLayers.length; i++) { + lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape); + } + this.validateModel(); + if (this.isValid) { + this.createModel(); + this.startInference(); + } + }; + ModelBuilder.prototype.downloadModel = function () { + var modelJson = this.getModelAsJson(); + var blob = new Blob([modelJson], { type: 'text/json' }); + var textFile = window.URL.createObjectURL(blob); + var a = document.createElement('a'); + document.body.appendChild(a); + a.style.display = 'none'; + a.href = textFile; + a.download = this.selectedDatasetName + '_model'; + a.click(); + document.body.removeChild(a); + window.URL.revokeObjectURL(textFile); + }; + ModelBuilder.prototype.uploadModel = function () { + this.querySelector('#model-file').click(); + }; + ModelBuilder.prototype.setupUploadModelButton = function () { + var _this = this; + var fileInput = this.querySelector('#model-file'); + fileInput.addEventListener('change', function (event) { + var file = fileInput.files[0]; + fileInput.value = ''; + var fileReader = new FileReader(); + fileReader.onload = function (evt) { + _this.removeAllLayers(); + var modelJson = fileReader.result; + _this.loadModelFromJson(modelJson); + }; + fileReader.readAsText(file); + }); + }; + ModelBuilder.prototype.getModelAsJson = function () { + var layerBuilders = []; + for (var i = 0; i < this.hiddenLayers.length; i++) { + layerBuilders.push(this.hiddenLayers[i].layerBuilder); + } + return JSON.stringify(layerBuilders); + }; + ModelBuilder.prototype.loadModelFromJson = function (modelJson) { + var lastOutputShape = this.inputShape; + var layerBuilders = JSON.parse(modelJson); + for (var i = 0; i < layerBuilders.length; i++) { + var modelLayer = this.addLayer(); + modelLayer.loadParamsFromLayerBuilder(lastOutputShape, layerBuilders[i]); + lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape); + } + this.validateModel(); + }; + ModelBuilder.prototype.uploadWeights = function () { + this.querySelector('#weights-file').click(); + }; + ModelBuilder.prototype.setupUploadWeightsButton = function () { + var _this = this; + var fileInput = this.querySelector('#weights-file'); + fileInput.addEventListener('change', function (event) { + var file = fileInput.files[0]; + fileInput.value = ''; + var fileReader = new FileReader(); + fileReader.onload = function (evt) { + var weightsJson = fileReader.result; + _this.loadWeightsFromJson(weightsJson); + _this.createModel(); + _this.startInference(); + }; + fileReader.readAsText(file); + }); + }; + ModelBuilder.prototype.loadWeightsFromJson = function (weightsJson) { + this.loadedWeights = JSON.parse(weightsJson); + }; + return ModelBuilder; +}(exports.ModelBuilderPolymer)); +exports.ModelBuilder = ModelBuilder; +document.registerElement(ModelBuilder.prototype.is, ModelBuilder); + +},{"../demo-footer":1,"../demo-header":2,"../learnjs":3,"../ndarray-image-visualizer":9,"../ndarray-logits-visualizer":10,"../polymer-spec":11,"../xhr-dataset":12,"./model-layer":6,"./model_builder_util":7,"./tensorflow":8}],6:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var polymer_spec_1 = require("../polymer-spec"); +var layer_builder = require("./layer_builder"); +var model_builder_util = require("./model_builder_util"); +exports.ModelLayerPolymer = polymer_spec_1.PolymerElement({ + is: 'model-layer', + properties: { + layerName: String, + inputShapeDisplay: String, + outputShapeDisplay: String, + isStatic: { type: Boolean, value: false }, + layerNames: Array, + selectedLayerName: String, + hasError: { type: Boolean, value: false }, + errorMessages: Array, + } +}); +var ModelLayer = (function (_super) { + __extends(ModelLayer, _super); + function ModelLayer() { + return _super !== null && _super.apply(this, arguments) || this; + } + ModelLayer.prototype.initialize = function (modelBuilder, inputShape) { + var _this = this; + this.modelBuilder = modelBuilder; + this.paramContainer = + this.querySelector('.param-container'); + this.layerNames = [ + 'Fully connected', 'ReLU', 'Convolution', 'Max pool', 'Reshape', 'Flatten' + ]; + this.inputShape = inputShape; + this.buildParamsUI('Fully connected', this.inputShape); + this.querySelector('.dropdown-content').addEventListener('iron-activate', function (event) { + _this.buildParamsUI(event.detail.selected, _this.inputShape); + }); + this.querySelector('#remove-layer').addEventListener('click', function (event) { + modelBuilder.removeLayer(_this); + }); + }; + ModelLayer.prototype.setInputShape = function (shape) { + this.inputShape = shape; + this.inputShapeDisplay = + model_builder_util.getDisplayShape(this.inputShape); + var errors = []; + var validationErrors = this.layerBuilder.validate(this.inputShape); + if (validationErrors != null) { + for (var i = 0; i < validationErrors.length; i++) { + errors.push('Error: ' + validationErrors[i]); + } + } + try { + this.outputShape = this.layerBuilder.getOutputShape(this.inputShape); + } + catch (e) { + errors.push(e); + } + this.outputShapeDisplay = + model_builder_util.getDisplayShape(this.outputShape); + if (errors.length > 0) { + this.hasError = true; + this.errorMessages = errors; + } + else { + this.hasError = false; + this.errorMessages = []; + } + return this.outputShape; + }; + ModelLayer.prototype.isValid = function () { + return !this.hasError; + }; + ModelLayer.prototype.getOutputShape = function () { + return this.outputShape; + }; + ModelLayer.prototype.addLayer = function (g, network, index, weights) { + return this.layerBuilder.addLayer(g, network, this.inputShape, index, weights); + }; + ModelLayer.prototype.buildParamsUI = function (layerName, inputShape, layerBuilderJson) { + this.selectedLayerName = layerName; + this.layerBuilder = + layer_builder.getLayerBuilder(layerName, layerBuilderJson); + this.paramContainer.innerHTML = ''; + var layerParams = this.layerBuilder.getLayerParams(); + for (var i = 0; i < layerParams.length; i++) { + var initialValue = layerBuilderJson != null ? + layerParams[i].getValue() : + layerParams[i].initialValue(inputShape); + this.addParamField(layerParams[i].label, initialValue, layerParams[i].setValue, layerParams[i].type, layerParams[i].min, layerParams[i].max); + } + this.modelBuilder.layerParamChanged(); + }; + ModelLayer.prototype.loadParamsFromLayerBuilder = function (inputShape, layerBuilderJson) { + this.buildParamsUI(layerBuilderJson.layerName, inputShape, layerBuilderJson); + }; + ModelLayer.prototype.addParamField = function (label, initialValue, setValue, type, min, max) { + var _this = this; + var input = document.createElement('paper-input'); + input.setAttribute('always-float-label', 'true'); + input.setAttribute('label', label); + input.setAttribute('value', '' + initialValue); + input.setAttribute('type', type); + if (type === 'number') { + input.setAttribute('min', '' + min); + input.setAttribute('max', '' + max); + } + input.className = 'param-input'; + this.paramContainer.appendChild(input); + input.addEventListener('input', function (event) { + if (type === 'number') { + setValue(event.target.valueAsNumber); + } + else { + setValue(event.target.value); + } + _this.modelBuilder.layerParamChanged(); + }); + setValue(initialValue); + }; + return ModelLayer; +}(exports.ModelLayerPolymer)); +exports.ModelLayer = ModelLayer; +document.registerElement(ModelLayer.prototype.is, ModelLayer); + +},{"../polymer-spec":11,"./layer_builder":4,"./model_builder_util":7}],7:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getDisplayShape(shape) { + return '[' + shape + ']'; +} +exports.getDisplayShape = getDisplayShape; + +},{}],8:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Normalization; +(function (Normalization) { + Normalization[Normalization["NORMALIZATION_NEGATIVE_ONE_TO_ONE"] = 0] = "NORMALIZATION_NEGATIVE_ONE_TO_ONE"; + Normalization[Normalization["NORMALIZATION_ZERO_TO_ONE"] = 1] = "NORMALIZATION_ZERO_TO_ONE"; + Normalization[Normalization["NORMALIZATION_NONE"] = 2] = "NORMALIZATION_NONE"; +})(Normalization = exports.Normalization || (exports.Normalization = {})); +function generatePython(datasetName, normalizationStrategy, inputShape, modelLayers) { + var loadData = generateLoadData(datasetName, normalizationStrategy); + var buildModel = generateBuildModel(inputShape, modelLayers); + var captureWeights = generateCaptureWeights(modelLayers); + return [loadData, buildModel, captureWeights].join('\n\n'); +} +exports.generatePython = generatePython; +function generateLoadData(datasetName, normalizationStrategy) { + var loadFunction; + switch (datasetName) { + case 'CIFAR 10': { + loadFunction = 'cifar10'; + break; + } + case 'MNIST': { + loadFunction = 'mnist'; + break; + } + default: { + throw new Error('datasetName must be \'CIFAR 10\' or \'MNIST\''); + } + } + var normString; + switch (normalizationStrategy) { + case Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE: { + normString = 'NORMALIZATION_NEGATIVE_ONE_TO_ONE'; + break; + } + case Normalization.NORMALIZATION_ZERO_TO_ONE: { + normString = 'NORMALIZATION_ZERO_TO_ONE'; + break; + } + case Normalization.NORMALIZATION_NONE: { + normString = 'NORMALIZATION_NONE'; + break; + } + default: { + throw new Error('invalid normalizationStrategy value'); + } + } + return "def load_data():\n return learnjs_colab.load_" + loadFunction + "(learnjs_colab." + normString + ")\n"; +} +function generateBuildModelLayer(layerIndex, inputShape, layer) { + var src = ''; + var W = 'W_' + layerIndex; + var b = 'b_' + layerIndex; + var outputShape = layer.getOutputShape(inputShape); + switch (layer.layerName) { + case 'Fully connected': { + var shape = [inputShape[0], outputShape].join(', '); + src = " " + W + " = tf.Variable(tf.truncated_normal([" + shape + "],\n stddev = 1.0 / math.sqrt(" + outputShape[0] + ")))\n " + b + " = tf.Variable(tf.truncated_normal([" + outputShape[0] + "], stddev = 0.1))\n layers.append({ 'x': layers[-1]['y'],\n 'W': " + W + ",\n 'b': " + b + ",\n 'y': tf.add(tf.matmul(layers[-1]['y'], " + W + "), " + b + ") })"; + break; + } + case 'ReLU': { + src = " layers.append({ 'x': layers[-1]['y'],\n 'y': tf.nn.relu(layers[-1]['y']) })"; + break; + } + case 'Convolution': { + var conv = layer; + var f = conv.fieldSize; + var d1 = inputShape[inputShape.length - 1]; + var d2 = outputShape[outputShape.length - 1]; + var wShape = '[' + f + ', ' + f + ', ' + d1 + ', ' + d2 + ']'; + var stride = '[1, ' + conv.stride + ', ' + conv.stride + ', 1]'; + src = " " + W + " = tf.Variable(tf.truncated_normal(" + wShape + ", stddev = 0.1))\n " + b + " = tf.Variable(tf.truncated_normal([" + d2 + "], stddev = 0.1))\n layers.append({ 'x': layers[-1]['y'],\n 'W': " + W + ",\n 'b': " + b + ",\n 'y': tf.add(tf.nn.conv2d(layers[-1]['y'],\n " + W + ",\n strides = " + stride + ",\n padding = 'SAME'), " + b + ") })"; + break; + } + case 'Max pool': { + var mp = layer; + var field = '[1, ' + mp.fieldSize + ', ' + mp.fieldSize + ', 1]'; + var stride = '[1, ' + mp.stride + ', ' + mp.stride + ', 1]'; + src = " layers.append({ 'x': layers[-1]['y'],\n 'y': tf.nn.max_pool(layers[-1]['y'],\n " + field + ",\n " + stride + ",\n padding = 'SAME') })"; + break; + } + case 'Reshape': { + break; + } + case 'Flatten': { + src = " layers.append({ 'x': layers[-1]['y'],\n 'y': tf.reshape(layers[-1]['y'], [-1, " + outputShape[0] + "]) })"; + break; + } + default: { + throw new Error('unknown layer type \'' + layer.layerName + '\''); + } + } + return src; +} +function generateBuildModel(inputShape, modelLayers) { + var inputShapeStr = inputShape.join(', '); + var sources = []; + sources.push("def build_model():\n layers = []\n\n layers.append({ 'y': tf.placeholder(tf.float32, [None, " + inputShapeStr + "]),\n 'y_label': tf.placeholder(tf.float32, [None, 10]) })"); + for (var i = 0; i < modelLayers.length; ++i) { + sources.push(generateBuildModelLayer(i + 1, inputShape, modelLayers[i])); + inputShape = modelLayers[i].getOutputShape(inputShape); + } + sources.push(' return layers\n'); + return sources.join('\n\n'); +} +function generateCaptureWeights(modelLayers) { + var sources = []; + sources.push("def capture_weights():\n weights = []"); + for (var i = 0; i < modelLayers.length; ++i) { + var layer = modelLayers[i]; + var index = i + 1; + var src = ''; + var W = '\'W\': model[' + index + '][\'W\']'; + var b = '\'b\': model[' + index + '][\'b\']'; + switch (layer.layerName) { + case 'Fully connected': { + src = " weights.append({ " + W + ".eval().flatten().tolist(),\n " + b + ".eval().flatten().tolist() })"; + break; + } + case 'Convolution': { + src = " weights.append({ " + W + ".eval().transpose().flatten().tolist(),\n " + b + ".eval().flatten().tolist() })"; + break; + } + default: { + src = ' weights.append({})'; + } + } + src += ' # ' + layer.layerName; + sources.push(src); + } + sources.push(' return weights'); + return sources.join('\n'); +} + +},{}],9:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var polymer_spec_1 = require("./polymer-spec"); +exports.NDArrayImageVisualizerPolymer = polymer_spec_1.PolymerElement({ is: 'ndarray-image-visualizer', properties: {} }); +var NDArrayImageVisualizer = (function (_super) { + __extends(NDArrayImageVisualizer, _super); + function NDArrayImageVisualizer() { + return _super !== null && _super.apply(this, arguments) || this; + } + NDArrayImageVisualizer.prototype.ready = function () { + this.canvas = this.querySelector('#canvas'); + this.canvas.width = 0; + this.canvas.height = 0; + this.canvasContext = + this.canvas.getContext('2d'); + this.canvas.style.display = 'none'; + }; + NDArrayImageVisualizer.prototype.setShape = function (shape) { + this.canvas.width = shape[1]; + this.canvas.height = shape[0]; + }; + NDArrayImageVisualizer.prototype.setSize = function (width, height) { + this.canvas.style.width = width + 'px'; + this.canvas.style.height = height + 'px'; + }; + NDArrayImageVisualizer.prototype.saveImageDataFromNDArray = function (ndarray) { + this.imageData = this.canvasContext.createImageData(this.canvas.width, this.canvas.height); + if (ndarray.shape[2] === 1) { + this.drawGrayscaleImageData(ndarray); + } + else if (ndarray.shape[2] === 3) { + this.drawRGBImageData(ndarray); + } + }; + NDArrayImageVisualizer.prototype.drawRGBImageData = function (ndarray) { + var pixelOffset = 0; + for (var i = 0; i < ndarray.shape[0]; i++) { + for (var j = 0; j < ndarray.shape[1]; j++) { + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 1); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 2); + this.imageData.data[pixelOffset++] = 255; + } + } + }; + NDArrayImageVisualizer.prototype.drawGrayscaleImageData = function (ndarray) { + var pixelOffset = 0; + for (var i = 0; i < ndarray.shape[0]; i++) { + for (var j = 0; j < ndarray.shape[1]; j++) { + var value = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = 255; + } + } + }; + NDArrayImageVisualizer.prototype.draw = function () { + this.canvas.style.display = ''; + this.canvasContext.putImageData(this.imageData, 0, 0); + }; + return NDArrayImageVisualizer; +}(exports.NDArrayImageVisualizerPolymer)); +exports.NDArrayImageVisualizer = NDArrayImageVisualizer; +document.registerElement(NDArrayImageVisualizer.prototype.is, NDArrayImageVisualizer); + +},{"./polymer-spec":11}],10:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var math_cpu_1 = require("../src/math/math_cpu"); +var polymer_spec_1 = require("./polymer-spec"); +var TOP_K = 3; +exports.NDArrayLogitsVisualizerPolymer = polymer_spec_1.PolymerElement({ is: 'ndarray-logits-visualizer', properties: {} }); +var NDArrayLogitsVisualizer = (function (_super) { + __extends(NDArrayLogitsVisualizer, _super); + function NDArrayLogitsVisualizer() { + return _super !== null && _super.apply(this, arguments) || this; + } + NDArrayLogitsVisualizer.prototype.initialize = function (width, height) { + this.width = width; + this.logitLabelElements = []; + this.logitVizElements = []; + var container = this.querySelector('.logits-container'); + container.style.height = height + 'px'; + for (var i = 0; i < TOP_K; i++) { + var logitContainer = document.createElement('div'); + logitContainer.style.height = height / (TOP_K + 1) + 'px'; + logitContainer.style.margin = + height / ((2 * TOP_K) * (TOP_K + 1)) + 'px 0'; + logitContainer.className = + 'single-logit-container ndarray-logits-visualizer'; + var logitLabelElement = document.createElement('div'); + logitLabelElement.className = 'logit-label ndarray-logits-visualizer'; + this.logitLabelElements.push(logitLabelElement); + var logitVizOuterElement = document.createElement('div'); + logitVizOuterElement.className = + 'logit-viz-outer ndarray-logits-visualizer'; + var logitVisInnerElement = document.createElement('div'); + logitVisInnerElement.className = + 'logit-viz-inner ndarray-logits-visualizer'; + logitVisInnerElement.innerHTML = ' '; + logitVizOuterElement.appendChild(logitVisInnerElement); + this.logitVizElements.push(logitVisInnerElement); + logitContainer.appendChild(logitLabelElement); + logitContainer.appendChild(logitVizOuterElement); + container.appendChild(logitContainer); + } + }; + NDArrayLogitsVisualizer.prototype.drawLogits = function (predictedLogits, labelLogits, labelClassNames) { + var mathCpu = new math_cpu_1.NDArrayMathCPU(); + var labelClass = mathCpu.argMax(labelLogits).get(); + var topk = mathCpu.topK(predictedLogits, TOP_K); + var topkIndices = topk.indices.getValues(); + var topkValues = topk.values.getValues(); + for (var i = 0; i < topkIndices.length; i++) { + var index = topkIndices[i]; + this.logitLabelElements[i].innerText = + labelClassNames ? labelClassNames[index] : index + ''; + this.logitLabelElements[i].style.width = + labelClassNames != null ? '100px' : '20px'; + this.logitVizElements[i].style.backgroundColor = index === labelClass ? + 'rgba(120, 185, 50, .84)' : + 'rgba(220, 10, 10, 0.84)'; + this.logitVizElements[i].style.width = + Math.floor(100 * topkValues[i]) + '%'; + this.logitVizElements[i].innerText = + (100 * topkValues[i]).toFixed(1) + "%"; + } + }; + return NDArrayLogitsVisualizer; +}(exports.NDArrayLogitsVisualizerPolymer)); +exports.NDArrayLogitsVisualizer = NDArrayLogitsVisualizer; +document.registerElement(NDArrayLogitsVisualizer.prototype.is, NDArrayLogitsVisualizer); + +},{"../src/math/math_cpu":28,"./polymer-spec":11}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function PolymerElement(spec) { + return Polymer.Class(spec); +} +exports.PolymerElement = PolymerElement; + +},{}],12:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var dataset_1 = require("../src/dataset"); +var ndarray_1 = require("../src/math/ndarray"); +var util = require("../src/util"); +var PARSING_IMAGE_CANVAS_HEIGHT_PX = 1000; +function getXhrDatasetConfig(jsonConfigPath) { + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', jsonConfigPath); + xhr.onload = function () { + resolve(JSON.parse(xhr.responseText)); + }; + xhr.onerror = function (error) { + reject(error); + }; + xhr.send(); + }); +} +exports.getXhrDatasetConfig = getXhrDatasetConfig; +var XhrDataset = (function (_super) { + __extends(XhrDataset, _super); + function XhrDataset(xhrDatasetConfig) { + var _this = _super.call(this, xhrDatasetConfig.data.map(function (x) { return x.shape; })) || this; + _this.xhrDatasetConfig = xhrDatasetConfig; + return _this; + } + XhrDataset.prototype.getNDArray = function (info) { + var dataPromise = info.dataType === 'png' ? + parseTypedArrayFromPng(info, info.shape) : + parseTypedArrayFromBinary(info); + return dataPromise.then(function (data) { + var inputSize = util.sizeFromShape(info.shape); + var ndarrays = []; + for (var i = 0; i < data.length / inputSize; i++) { + var values = data.subarray(i * inputSize, (i + 1) * inputSize); + var ndarray = ndarray_1.NDArray.make(info.shape, { values: new Float32Array(values) }); + ndarrays.push(ndarray); + } + return ndarrays; + }); + }; + XhrDataset.prototype.fetchData = function () { + var _this = this; + return new Promise(function (resolve, reject) { + var promises = _this.xhrDatasetConfig.data.map(function (x) { return _this.getNDArray(x); }); + Promise.all(promises).then(function (data) { + _this.dataset = data; + resolve(); + }); + }); + }; + return XhrDataset; +}(dataset_1.InMemoryDataset)); +exports.XhrDataset = XhrDataset; +function parseTypedArrayFromBinary(info) { + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', info.path); + xhr.responseType = 'arraybuffer'; + xhr.onload = function (event) { + var data = (info.dataType === 'float32') ? + new Float32Array(xhr.response) : + new Uint8Array(xhr.response); + resolve(data); + }; + xhr.onerror = function (err) { return reject(err); }; + xhr.send(); + }); +} +function parseGrayscaleImageData(data, result, resultOffset) { + var idx = resultOffset; + for (var i = 0; i < data.length; i += 4) { + result[idx++] = data[i]; + } +} +function parseRGBImageData(data, result, resultOffset) { + var idx = resultOffset; + for (var i = 0; i < data.length; i += 4) { + result[idx] = data[i]; + result[idx + 1] = data[i + 1]; + result[idx + 2] = data[i + 2]; + idx += 3; + } +} +function parseImage(img, shape) { + var canvas = document.createElement('canvas'); + var ctx = canvas.getContext('2d'); + var N = img.height; + var inputSize = util.sizeFromShape(shape); + var result = new Uint8Array(N * inputSize); + if (img.width !== shape[0] * shape[1]) { + throw new Error("Image width (" + img.width + ") must be multiple of " + + ("rows*columns (" + shape[0] + "*" + shape[1] + ") of the ndarray")); + } + canvas.width = img.width; + canvas.height = PARSING_IMAGE_CANVAS_HEIGHT_PX; + var sx = 0; + var sWidth = canvas.width; + var sHeight = canvas.height; + var dx = 0; + var dy = 0; + var dWidth = sWidth; + var dHeight = sHeight; + var depth = shape[2]; + var offset = 0; + var numPasses = Math.ceil(N / canvas.height); + for (var pass = 0; pass < numPasses; ++pass) { + var sy = pass * canvas.height; + if ((pass === numPasses - 1) && (N % canvas.height > 0)) { + canvas.height = N % canvas.height; + sHeight = canvas.height; + dHeight = sHeight; + } + ctx.drawImage(img, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight); + var data = ctx.getImageData(0, 0, canvas.width, canvas.height).data; + (depth === 1) ? parseGrayscaleImageData(data, result, offset) : + parseRGBImageData(data, result, offset); + offset += canvas.height * inputSize; + } + return result; +} +function parseTypedArrayFromPng(info, shape) { + return new Promise(function (resolve, reject) { + var img = new Image(); + img.setAttribute('crossOrigin', ''); + img.onload = function () { + var result = parseImage(img, shape); + img.src = ''; + img = null; + resolve(result); + }; + img.src = info.path; + }); +} + +},{"../src/dataset":14,"../src/math/ndarray":30,"../src/util":94}],13:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var MANIFEST_FILE = 'manifest.json'; +var CheckpointLoader = (function () { + function CheckpointLoader(urlPath) { + this.urlPath = urlPath; + if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') { + this.urlPath += '/'; + } + } + CheckpointLoader.prototype.loadManifest = function () { + var _this = this; + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', _this.urlPath + MANIFEST_FILE); + xhr.onload = function () { + _this.checkpointManifest = JSON.parse(xhr.responseText); + resolve(); + }; + xhr.onerror = function (error) { + throw new Error(MANIFEST_FILE + " not found at " + _this.urlPath + ". " + error); + }; + xhr.send(); + }); + }; + CheckpointLoader.prototype.getCheckpointManifest = function () { + var _this = this; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + resolve(_this.checkpointManifest); + }); + }); + } + return new Promise(function (resolve, reject) { + resolve(_this.checkpointManifest); + }); + }; + CheckpointLoader.prototype.getAllVariables = function () { + var _this = this; + if (this.variables != null) { + return new Promise(function (resolve, reject) { + resolve(_this.variables); + }); + } + return new Promise(function (resolve, reject) { + _this.getCheckpointManifest().then(function (checkpointDefinition) { + var variableNames = Object.keys(_this.checkpointManifest); + var variablePromises = []; + for (var i = 0; i < variableNames.length; i++) { + variablePromises.push(_this.getVariable(variableNames[i])); + } + Promise.all(variablePromises).then(function (variables) { + _this.variables = {}; + for (var i = 0; i < variables.length; i++) { + _this.variables[variableNames[i]] = variables[i]; + } + resolve(_this.variables); + }); + }); + }); + }; + CheckpointLoader.prototype.getVariable = function (varName) { + var _this = this; + if (!(varName in this.checkpointManifest)) { + throw new Error('Cannot load non-existant variable ' + varName); + } + var variableRequestPromiseMethod = function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.responseType = 'arraybuffer'; + var fname = _this.checkpointManifest[varName].filename; + xhr.open('GET', _this.urlPath + fname); + xhr.onload = function () { + var values = new Float32Array(xhr.response); + var ndarray = ndarray_1.NDArray.make(_this.checkpointManifest[varName].shape, { values: values }); + resolve(ndarray); + }; + xhr.onerror = function (error) { + throw new Error('Could not fetch variable ' + varName + ': ' + error); + }; + xhr.send(); + }; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + new Promise(variableRequestPromiseMethod).then(resolve); + }); + }); + } + return new Promise(variableRequestPromiseMethod); + }; + return CheckpointLoader; +}()); +exports.CheckpointLoader = CheckpointLoader; + +},{"./math/ndarray":30}],14:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var STATS_SAMPLE_PERCENTAGE = 0.1; +var InMemoryDataset = (function () { + function InMemoryDataset(dataShapes) { + this.dataShapes = dataShapes; + this.normalizationInfo = {}; + } + InMemoryDataset.prototype.getDataShape = function (dataIndex) { + return this.dataShapes[dataIndex]; + }; + InMemoryDataset.prototype.getData = function () { + return this.dataset; + }; + InMemoryDataset.prototype.getStats = function () { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + return this.dataset.map(function (d) { return _this.getStatsForData(d); }); + }; + InMemoryDataset.prototype.getStatsForData = function (data) { + var inputMin = Number.POSITIVE_INFINITY; + var inputMax = Number.NEGATIVE_INFINITY; + var exampleIndices = data.map(function (example, i) { return i; }); + util.shuffle(exampleIndices); + exampleIndices = + exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE); + for (var i = 0; i < exampleIndices.length; i++) { + var inputValues = data[exampleIndices[i]].getValues(); + for (var j = 0; j < inputValues.length; j++) { + inputMin = Math.min(inputMin, inputValues[j]); + inputMax = Math.max(inputMax, inputValues[j]); + } + } + return { + inputMin: inputMin, + inputMax: inputMax, + exampleCount: data.length, + shape: data[0].shape, + }; + }; + InMemoryDataset.prototype.normalizeExamplesToRange = function (examples, curLowerBounds, curUpperBounds, newLowerBounds, newUpperBounds) { + var curBoundsIsPerDimension = (curUpperBounds instanceof Float32Array && + curLowerBounds instanceof Float32Array); + var newBoundsIsPerDimension = (newLowerBounds instanceof Float32Array && + newUpperBounds instanceof Float32Array); + var inputSize = util.sizeFromShape(examples[0].shape); + var newExamples = []; + examples.forEach(function (example) { + var inputValues = example.getValues(); + var normalizedValues = new Float32Array(inputSize); + for (var j = 0; j < inputSize; j++) { + var curLowerBound = curBoundsIsPerDimension ? + curLowerBounds[j] : + curLowerBounds; + var curUpperBound = curBoundsIsPerDimension ? + curUpperBounds[j] : + curUpperBounds; + var curRange = curUpperBound - curLowerBound; + var newLowerBound = newBoundsIsPerDimension ? + newLowerBounds[j] : + newLowerBounds; + var newUpperBound = newBoundsIsPerDimension ? + newUpperBounds[j] : + newUpperBounds; + var newRange = newUpperBound - newLowerBound; + if (curRange === 0) { + normalizedValues[j] = newLowerBound; + } + else { + normalizedValues[j] = newLowerBound + + newRange * (inputValues[j] - curLowerBound) / curRange; + } + } + newExamples.push(ndarray_1.NDArray.make(example.shape, { values: normalizedValues })); + }); + return newExamples; + }; + InMemoryDataset.prototype.computeBounds = function (dataIndex) { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + var size = util.sizeFromShape(this.dataset[dataIndex][0].shape); + this.normalizationInfo[dataIndex] = { + isNormalized: false, + minValues: new Float32Array(size), + maxValues: new Float32Array(size) + }; + for (var i = 0; i < size; i++) { + this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY; + this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY; + } + this.dataset[dataIndex].forEach(function (example) { + var inputValues = example.getValues(); + for (var k = 0; k < size; k++) { + _this.normalizationInfo[dataIndex].minValues[k] = Math.min(_this.normalizationInfo[dataIndex].minValues[k], inputValues[k]); + _this.normalizationInfo[dataIndex].maxValues[k] = Math.max(_this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]); + } + }); + }; + InMemoryDataset.prototype.normalizeWithinBounds = function (dataIndex, lowerBound, upperBound) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + if (dataIndex >= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":30,"./util":94}],15:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":16,"./math/concat3d_util":23,"./math/conv_util":24,"./math/ndarray":30,"./util":94}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":20}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":30,"./session":90}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":15,"./priority_queue":89}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":13,"./dataset":14,"./graph":15,"./graph_runner":17,"./initializers":20,"./input_provider":21,"./math/conv_util":24,"./math/math":27,"./math/math_cpu":28,"./math/math_gpu":29,"./math/ndarray":30,"./math/webgl/gpgpu_context":43,"./math/webgl/gpgpu_util":44,"./math/webgl/render_ndarray_gpu_util":56,"./math/webgl/webgl_util":66,"./optimizer":88,"./session":90,"./sgd_optimizer":92,"./util":94}],20:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":30}],21:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":30,"./util":94}],22:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":30}],23:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":94}],24:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":94}],25:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":30}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":94,"./concat3d_util":23,"./copy2d_util":25,"./ndarray":30}],28:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":24,"../util":94,"./concat3d_util":23,"./copy2d_util":25,"./math":27,"./ndarray":30}],29:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":94,"./concat3d_util":23,"./conv_util":24,"./math":27,"./ndarray":30,"./webgl/addscaledmat_gpu":31,"./webgl/addsubmuldiv_gpu":32,"./webgl/argmaxequals_gpu":33,"./webgl/argminmax_gpu":34,"./webgl/avg_pool_gpu":35,"./webgl/batchnorm_gpu":36,"./webgl/concat3d_gpu":38,"./webgl/conv_backprop_gpu":39,"./webgl/conv_gpu":40,"./webgl/copy_gpu":41,"./webgl/exp_gpu":42,"./webgl/gpgpu_context":43,"./webgl/gpgpu_util":44,"./webgl/log_gpu":45,"./webgl/logsumexp_gpu":46,"./webgl/max_pool_backprop_gpu":47,"./webgl/max_pool_gpu":48,"./webgl/min_pool_gpu":49,"./webgl/minmax_gpu":50,"./webgl/mulmat_gpu":51,"./webgl/neg_gpu":52,"./webgl/pool_gpu":53,"./webgl/reducesum_gpu":54,"./webgl/relu_gpu":55,"./webgl/reshape_gpu":57,"./webgl/resize_bilinear_gpu":58,"./webgl/shader_compiler":59,"./webgl/sigmoid_gpu":60,"./webgl/step_gpu":61,"./webgl/texture_manager":63,"./webgl/trig_gpu":64,"./webgl/webgl_util":66}],30:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":94,"./webgl/webgl_util":66}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":43}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":27,"./binaryop_gpu":37}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":34}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":66}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":53}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":43}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":24}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":24,"./conv_gpu":40}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":24}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":65}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":44,"./tex_util":62,"./webgl_util":66}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":62,"./webgl_util":66}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":65}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":43}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":24}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":53}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":53}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":66}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":27,"./shader_compiler":59}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":65}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":24,"./webgl_util":66}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":43}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":65}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":66}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":94}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":24}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":94}],60:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":65}],61:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":65}],62:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],63:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],64:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":65}],65:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":43}],66:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":94}],67:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":15,"./graph_util":18,"./ops/add":68,"./ops/argmax":69,"./ops/argmaxequals":70,"./ops/concat3d":71,"./ops/convolution":72,"./ops/divide":73,"./ops/element_wise_activation":74,"./ops/element_wise_cost":75,"./ops/exp":76,"./ops/linear_combination":77,"./ops/log":78,"./ops/matmul":79,"./ops/max_pool":80,"./ops/multiply":81,"./ops/reduce_sum":83,"./ops/reshape":84,"./ops/softmax":85,"./ops/split":86,"./ops/subtract":87}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":18,"../math/ndarray":30,"../util":94,"./op":82}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":82}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":82}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":23,"./op":82}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":24,"../util":94,"./op":82}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":18,"../util":94,"./op":82}],74:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":22,"./op":82}],75:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":18,"../math/cost_functions":26,"../math/ndarray":30,"../util":94,"./op":82}],76:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":18,"./op":82}],77:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":18,"./op":82}],78:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":18,"./op":82}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":18,"../math/math":27,"./op":82}],80:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":24,"../util":94,"./op":82}],81:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":18,"../util":94,"./op":82}],82:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],83:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":18,"../math/ndarray":30,"../util":94,"./op":82}],84:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":94,"./op":82}],85:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":15,"../math/ndarray":30,"../util":94,"./op":82}],86:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":18,"../util":94,"./op":82}],87:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":18,"../math/ndarray":30,"../util":94,"./op":82}],88:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],89:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],90:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":30,"./operation_emitter":67,"./session_util":91,"./tensor_array_map":93,"./util":94}],91:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":15,"./graph_util":18,"./math/ndarray":30,"./util":94}],92:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":30,"./optimizer":88,"./session_util":91,"./tensor_array_map":93}],93:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],94:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[5]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","demos/demo-footer.ts","demos/demo-header.ts","demos/learnjs.ts","demos/model-builder/layer_builder.ts","demos/model-builder/model-builder.ts","demos/model-builder/model-layer.ts","demos/model-builder/model_builder_util.ts","demos/model-builder/tensorflow.ts","demos/ndarray-image-visualizer.ts","demos/ndarray-logits-visualizer.ts","demos/polymer-spec.ts","demos/xhr-dataset.ts","src/checkpoint_loader.ts","src/dataset.ts","src/graph.ts","src/graph_layers.ts","src/graph_runner.ts","src/graph_util.ts","src/index.ts","src/initializers.ts","src/input_provider.ts","src/math/activation_functions.ts","src/math/concat3d_util.ts","src/math/conv_util.ts","src/math/copy2d_util.ts","src/math/cost_functions.ts","src/math/math.ts","src/math/math_cpu.ts","src/math/math_gpu.ts","src/math/ndarray.ts","src/math/webgl/addscaledmat_gpu.ts","src/math/webgl/addsubmuldiv_gpu.ts","src/math/webgl/argmaxequals_gpu.ts","src/math/webgl/argminmax_gpu.ts","src/math/webgl/avg_pool_gpu.ts","src/math/webgl/batchnorm_gpu.ts","src/math/webgl/binaryop_gpu.ts","src/math/webgl/concat3d_gpu.ts","src/math/webgl/conv_backprop_gpu.ts","src/math/webgl/conv_gpu.ts","src/math/webgl/copy_gpu.ts","src/math/webgl/exp_gpu.ts","src/math/webgl/gpgpu_context.ts","src/math/webgl/gpgpu_util.ts","src/math/webgl/log_gpu.ts","src/math/webgl/logsumexp_gpu.ts","src/math/webgl/max_pool_backprop_gpu.ts","src/math/webgl/max_pool_gpu.ts","src/math/webgl/min_pool_gpu.ts","src/math/webgl/minmax_gpu.ts","src/math/webgl/mulmat_gpu.ts","src/math/webgl/neg_gpu.ts","src/math/webgl/pool_gpu.ts","src/math/webgl/reducesum_gpu.ts","src/math/webgl/relu_gpu.ts","src/math/webgl/render_ndarray_gpu_util.ts","src/math/webgl/reshape_gpu.ts","src/math/webgl/resize_bilinear_gpu.ts","src/math/webgl/shader_compiler.ts","src/math/webgl/sigmoid_gpu.ts","src/math/webgl/step_gpu.ts","src/math/webgl/tex_util.ts","src/math/webgl/texture_manager.ts","src/math/webgl/trig_gpu.ts","src/math/webgl/unaryop_gpu.ts","src/math/webgl/webgl_util.ts","src/operation_emitter.ts","src/ops/add.ts","src/ops/argmax.ts","src/ops/argmaxequals.ts","src/ops/concat3d.ts","src/ops/convolution.ts","src/ops/divide.ts","src/ops/element_wise_activation.ts","src/ops/element_wise_cost.ts","src/ops/exp.ts","src/ops/linear_combination.ts","src/ops/log.ts","src/ops/matmul.ts","src/ops/max_pool.ts","src/ops/multiply.ts","src/ops/op.ts","src/ops/reduce_sum.ts","src/ops/reshape.ts","src/ops/softmax.ts","src/ops/split.ts","src/ops/subtract.ts","src/optimizer.ts","src/priority_queue.ts","src/session.ts","src/session_util.ts","src/sgd_optimizer.ts","src/tensor_array_map.ts","src/util.ts"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-footer'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-header'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// This file is just an alias that points to the current learnjs version\n// at this branch, so demos can import the library as '../learnjs'.\nexport * from '../src/index';\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Array1D, Array2D, Array4D, conv_util, Graph, Initializer, NDArray, NDArrayInitializer, Tensor, util, VarianceScalingInitializer, ZerosInitializer} from '../learnjs';\n\n/**\n * Classes that specify operation parameters, how they affect output shape,\n * and methods for building the operations themselves. Any new ops to be added\n * to the model builder UI should be added here.\n */\n\nexport type LayerName = 'Fully connected' | 'ReLU' | 'Convolution' |\n    'Max pool' | 'Reshape' | 'Flatten';\n\n/**\n * Creates a layer builder object.\n *\n * @param layerName The name of the layer to build.\n * @param layerBuilderJson An optional LayerBuilder JSON object. This doesn't\n *     have the prototype methods on them as it comes from serialization. This\n *     method creates the object with the necessary prototype methods.\n */\nexport function getLayerBuilder(\n    layerName: LayerName, layerBuilderJson?: LayerBuilder): LayerBuilder {\n  let layerBuilder: LayerBuilder;\n  switch (layerName) {\n    case 'Fully connected':\n      layerBuilder = new FullyConnectedLayerBuilder();\n      break;\n    case 'ReLU':\n      layerBuilder = new ReLULayerBuilder();\n      break;\n    case 'Convolution':\n      layerBuilder = new Convolution2DLayerBuilder();\n      break;\n    case 'Max pool':\n      layerBuilder = new MaxPoolLayerBuilder();\n      break;\n    case 'Reshape':\n      layerBuilder = new ReshapeLayerBuilder();\n      break;\n    case 'Flatten':\n      layerBuilder = new FlattenLayerBuilder();\n      break;\n    default:\n      throw new Error('Layer builder for ' + layerName + ' not found.');\n  }\n\n  // For layer builders passed as serialized objects, we create the objects and\n  // set the fields.\n  if (layerBuilderJson != null) {\n    for (const prop in layerBuilderJson) {\n      if (layerBuilderJson.hasOwnProperty(prop)) {\n        // tslint:disable-next-line:no-any\n        (layerBuilder as any)[prop] = (layerBuilderJson as any)[prop];\n      }\n    }\n  }\n  return layerBuilder;\n}\n\nexport interface LayerParam {\n  label: string;\n  initialValue(inputShape: number[]): number|string;\n  type: 'number'|'text';\n  min?: number;\n  max?: number;\n  setValue(value: number|string): void;\n  getValue(): number|string;\n}\n\nexport type LayerWeightsDict = {\n  [name: string]: number[]\n};\n\nexport interface LayerBuilder {\n  layerName: LayerName;\n  getLayerParams(): LayerParam[];\n  getOutputShape(inputShape: number[]): number[];\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights?: LayerWeightsDict|null): Tensor;\n  // Return null if no errors, otherwise return an array of errors.\n  validate(inputShape: number[]): string[]|null;\n}\n\nexport class FullyConnectedLayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'Fully connected';\n  hiddenUnits: number;\n\n  getLayerParams(): LayerParam[] {\n    return [{\n      label: 'Hidden units',\n      initialValue: (inputShape: number[]) => 10,\n      type: 'number',\n      min: 1,\n      max: 1000,\n      setValue: (value: number) => this.hiddenUnits = value,\n      getValue: () => this.hiddenUnits\n    }];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return [this.hiddenUnits];\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    const inputSize = util.sizeFromShape(inputShape);\n    const wShape: [number, number] = [this.hiddenUnits, inputSize];\n\n    let weightsInitializer: Initializer;\n    let biasInitializer: Initializer;\n    if (weights != null) {\n      weightsInitializer =\n          new NDArrayInitializer(Array2D.new(wShape, weights['W']));\n      biasInitializer = new NDArrayInitializer(Array1D.new(weights['b']));\n    } else {\n      weightsInitializer = new VarianceScalingInitializer();\n      biasInitializer = new ZerosInitializer();\n    }\n\n    const useBias = true;\n    return g.layers.dense(\n        'fc1', network, this.hiddenUnits, null, useBias, weightsInitializer,\n        biasInitializer);\n  }\n\n  validate(inputShape: number[]) {\n    if (inputShape.length !== 1) {\n      return ['Input shape must be a Array1D.'];\n    }\n    return null;\n  }\n}\n\nexport class ReLULayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'ReLU';\n  getLayerParams(): LayerParam[] {\n    return [];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return inputShape;\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    return g.relu(network);\n  }\n\n  validate(inputShape: number[]): string[]|null {\n    return null;\n  }\n}\n\nexport class Convolution2DLayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'Convolution';\n  fieldSize: number;\n  stride: number;\n  zeroPad: number;\n  outputDepth: number;\n\n  getLayerParams(): LayerParam[] {\n    return [\n      {\n        label: 'Field size',\n        initialValue: (inputShape: number[]) => 3,\n        type: 'number',\n        min: 1,\n        max: 100,\n        setValue: (value: number) => this.fieldSize = value,\n        getValue: () => this.fieldSize\n      },\n      {\n        label: 'Stride',\n        initialValue: (inputShape: number[]) => 1,\n        type: 'number',\n        min: 1,\n        max: 100,\n        setValue: (value: number) => this.stride = value,\n        getValue: () => this.stride\n      },\n      {\n        label: 'Zero pad',\n        initialValue: (inputShape: number[]) => 0,\n        type: 'number',\n        min: 0,\n        max: 100,\n        setValue: (value: number) => this.zeroPad = value,\n        getValue: () => this.zeroPad\n      },\n      {\n        label: 'Output depth',\n        initialValue: (inputShape: number[]) =>\n            this.outputDepth != null ? this.outputDepth : 1,\n        type: 'number',\n        min: 1,\n        max: 1000,\n        setValue: (value: number) => this.outputDepth = value,\n        getValue: () => this.outputDepth\n      }\n    ];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return conv_util.computeOutputShape3D(\n        inputShape as [number, number, number], this.fieldSize,\n        this.outputDepth, this.stride, this.zeroPad);\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    const inputShape3d = inputShape as [number, number, number];\n    const wShape: [number, number, number, number] =\n        [this.fieldSize, this.fieldSize, inputShape[2], this.outputDepth];\n    let w: Array4D;\n    let b: Array1D;\n    if (weights != null) {\n      w = Array4D.new(wShape, weights['W']);\n      b = Array1D.new(weights['b']);\n    } else {\n      w = NDArray.randTruncatedNormal<Array4D>(wShape, 0, 0.1);\n      b = Array1D.zeros([this.outputDepth]);\n    }\n    const wTensor = g.variable('conv2d-' + index + '-w', w);\n    const bTensor = g.variable('conv2d-' + index + '-b', b);\n    return g.conv2d(\n        network, wTensor, bTensor, this.fieldSize, this.outputDepth,\n        this.stride, this.zeroPad);\n  }\n\n  validate(inputShape: number[]) {\n    if (inputShape.length !== 3) {\n      return ['Input shape must be a Array3D.'];\n    }\n    return null;\n  }\n}\n\nexport class MaxPoolLayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'Max pool';\n  fieldSize: number;\n  stride: number;\n  zeroPad: number;\n\n  getLayerParams(): LayerParam[] {\n    return [\n      {\n        label: 'Field size',\n        initialValue: (inputShape: number[]) => 3,\n        type: 'number',\n        min: 1,\n        max: 100,\n        setValue: (value: number) => this.fieldSize = value,\n        getValue: () => this.fieldSize\n      },\n      {\n        label: 'Stride',\n        initialValue: (inputShape: number[]) => 1,\n        type: 'number',\n        min: 1,\n        max: 100,\n        setValue: (value: number) => this.stride = value,\n        getValue: () => this.stride\n      },\n      {\n        label: 'Zero pad',\n        initialValue: (inputShape: number[]) => 0,\n        type: 'number',\n        min: 0,\n        max: 100,\n        setValue: (value: number) => this.zeroPad = value,\n        getValue: () => this.zeroPad\n      }\n    ];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return conv_util.computeOutputShape3D(\n        inputShape as [number, number, number], this.fieldSize, inputShape[2],\n        this.stride, this.zeroPad);\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    return g.maxPool(network, this.fieldSize, this.stride, this.zeroPad);\n  }\n\n  validate(inputShape: number[]) {\n    if (inputShape.length !== 3) {\n      return ['Input shape must be a Array3D.'];\n    }\n    return null;\n  }\n}\n\nexport class ReshapeLayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'Reshape';\n  outputShape: number[];\n  getLayerParams() {\n    return [{\n      label: 'Shape (comma separated)',\n      initialValue: (inputShape: number[]) => inputShape.join(', '),\n      type: 'text' as 'text',\n      setValue: (value: string) => this.outputShape =\n          value.split(',').map((value) => +value),\n      getValue: () => this.outputShape.join(', ')\n    }];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return this.outputShape;\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    return g.reshape(network, this.outputShape);\n  }\n\n  validate(inputShape: number[]) {\n    const inputSize = util.sizeFromShape(inputShape);\n    const outputSize = util.sizeFromShape(this.outputShape);\n    if (inputSize !== outputSize) {\n      return [\n        `Input size (${inputSize}) must match output size (${outputSize}).`\n      ];\n    }\n    return null;\n  }\n}\n\nexport class FlattenLayerBuilder implements LayerBuilder {\n  layerName: LayerName = 'Flatten';\n\n  getLayerParams(): LayerParam[] {\n    return [];\n  }\n\n  getOutputShape(inputShape: number[]): number[] {\n    return [util.sizeFromShape(inputShape)];\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, inputShape: number[], index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    return g.reshape(network, this.getOutputShape(inputShape));\n  }\n\n  validate(inputShape: number[]): string[]|null {\n    return null;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// tslint:disable-next-line:no-unused-variable\nimport '../ndarray-image-visualizer';\nimport '../ndarray-logits-visualizer';\nimport './model-layer';\nimport '../demo-header';\nimport '../demo-footer';\n\nimport {Array1D, Array3D, DataStats, FeedEntry, Graph, GraphRunner, GraphRunnerEventObserver, InCPUMemoryShuffledInputProviderBuilder, InMemoryDataset, MetricReduction, NDArray, NDArrayMath, NDArrayMathCPU, NDArrayMathGPU, Optimizer, Scalar, Session, SGDOptimizer, Tensor, util} from '../learnjs';\nimport {NDArrayImageVisualizer} from '../ndarray-image-visualizer';\nimport {NDArrayLogitsVisualizer} from '../ndarray-logits-visualizer';\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\nimport * as xhr_dataset from '../xhr-dataset';\nimport {XhrDataset, XhrDatasetConfig} from '../xhr-dataset';\n\nimport {LayerBuilder, LayerWeightsDict} from './layer_builder';\nimport {ModelLayer} from './model-layer';\nimport * as model_builder_util from './model_builder_util';\nimport {Normalization} from './tensorflow';\n\nconst DATASETS_CONFIG_JSON = 'model-builder-datasets-config.json';\n\n// TODO(nsthorat): Make these parameters in the UI.\nconst BATCH_SIZE = 64;\nconst LEARNING_RATE = 0.1;\n/** How often to evaluate the model against test data. */\nconst EVAL_INTERVAL_MS = 1500;\n/** How often to compute the cost. Downloading the cost stalls the GPU. */\nconst COST_INTERVAL_MS = 500;\n/** How many inference examples to show when evaluating accuracy. */\nconst INFERENCE_EXAMPLE_COUNT = 15;\nconst INFERENCE_IMAGE_SIZE_PX = 100;\n/**\n * How often to show inference examples. This should be less often than\n * EVAL_INTERVAL_MS as we only show inference examples during an eval.\n */\nconst INFERENCE_EXAMPLE_INTERVAL_MS = 3000;\n\n// Smoothing factor for the examples/s standalone text statistic.\nconst EXAMPLE_SEC_STAT_SMOOTHING_FACTOR = .7;\n\nconst TRAIN_TEST_RATIO = 5 / 6;\n\nconst IMAGE_DATA_INDEX = 0;\nconst LABEL_DATA_INDEX = 1;\n\n// tslint:disable-next-line:variable-name\nexport let ModelBuilderPolymer = PolymerElement({\n  is: 'model-builder',\n  properties: {\n    inputShapeDisplay: String,\n    isValid: Boolean,\n    inferencesPerSec: Number,\n    inferenceDuration: Number,\n    examplesTrained: Number,\n    examplesPerSec: Number,\n    totalTimeSec: String,\n    applicationState: Number,\n    modelInitialized: Boolean,\n    showTrainStats: Boolean,\n    datasetDownloaded: Boolean,\n    datasetNames: Array,\n    selectedDatasetName: String,\n    modelNames: Array,\n    selectedModelName: String,\n    selectedNormalizationOption:\n        {type: Number, value: Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE},\n    // Stats\n    showDatasetStats: Boolean,\n    statsInputMin: Number,\n    statsInputMax: Number,\n    statsInputShapeDisplay: String,\n    statsLabelShapeDisplay: String,\n    statsExampleCount: Number,\n  }\n});\n\nexport enum ApplicationState {\n  IDLE = 1,\n  TRAINING = 2\n}\n\nexport class ModelBuilder extends ModelBuilderPolymer {\n  // Polymer properties.\n  private isValid: boolean;\n  private totalTimeSec: string;\n  private applicationState: ApplicationState;\n  private modelInitialized: boolean;\n  private showTrainStats: boolean;\n  private selectedNormalizationOption: number;\n\n  // Datasets and models.\n  private graphRunner: GraphRunner;\n  private graph: Graph;\n  private session: Session;\n  private optimizer: Optimizer;\n  private xTensor: Tensor;\n  private labelTensor: Tensor;\n  private costTensor: Tensor;\n  private accuracyTensor: Tensor;\n  private predictionTensor: Tensor;\n\n  private datasetDownloaded: boolean;\n  private datasetNames: string[];\n  private selectedDatasetName: string;\n  private modelNames: string[];\n  private selectedModelName: string;\n  private loadedWeights: LayerWeightsDict[]|null;\n  private dataSets: {[datasetName: string]: InMemoryDataset};\n  private dataSet: InMemoryDataset;\n  private xhrDatasetConfigs: {[datasetName: string]: XhrDatasetConfig};\n  private datasetStats: DataStats[];\n\n  // Stats.\n  private showDatasetStats: boolean;\n  private statsInputRange: string;\n  private statsInputShapeDisplay: string;\n  private statsLabelShapeDisplay: string;\n  private statsExampleCount: number;\n\n  // Charts.\n  private costChart: Chart;\n  private accuracyChart: Chart;\n  private examplesPerSecChart: Chart;\n  private costChartData: ChartPoint[];\n  private accuracyChartData: ChartPoint[];\n  private examplesPerSecChartData: ChartPoint[];\n\n  private trainButton: HTMLButtonElement;\n\n  // Visualizers.\n  private inputNDArrayVisualizers: NDArrayImageVisualizer[];\n  private outputNDArrayVisualizers: NDArrayLogitsVisualizer[];\n\n  private inputShape: number[];\n  private labelShape: number[];\n  private examplesPerSec: number;\n  private examplesTrained: number;\n  private inferencesPerSec: number;\n  private inferenceDuration: number;\n\n  private inputLayer: ModelLayer;\n  private hiddenLayers: ModelLayer[];\n\n  private layersContainer: HTMLDivElement;\n\n  private math: NDArrayMath;\n  // Keep one instance of each NDArrayMath so we don't create a user-initiated\n  // number of NDArrayMathGPU's.\n  private mathGPU: NDArrayMathGPU;\n  private mathCPU: NDArrayMathCPU;\n\n  ready() {\n    this.mathGPU = new NDArrayMathGPU();\n    this.mathCPU = new NDArrayMathCPU();\n    this.math = this.mathGPU;\n\n    const eventObserver: GraphRunnerEventObserver = {\n      batchesTrainedCallback: (batchesTrained: number) =>\n          this.displayBatchesTrained(batchesTrained),\n      avgCostCallback: (avgCost: Scalar) => this.displayCost(avgCost),\n      metricCallback: (metric: Scalar) => this.displayAccuracy(metric),\n      inferenceExamplesCallback:\n          (inputFeeds: FeedEntry[][], inferenceOutputs: NDArray[]) =>\n              this.displayInferenceExamplesOutput(inputFeeds, inferenceOutputs),\n      inferenceExamplesPerSecCallback: (examplesPerSec: number) =>\n          this.displayInferenceExamplesPerSec(examplesPerSec),\n      trainExamplesPerSecCallback: (examplesPerSec: number) =>\n          this.displayExamplesPerSec(examplesPerSec),\n      totalTimeCallback: (totalTimeSec: number) => this.totalTimeSec =\n          totalTimeSec.toFixed(1),\n    };\n    this.graphRunner = new GraphRunner(this.math, this.session, eventObserver);\n    this.optimizer = new SGDOptimizer(LEARNING_RATE);\n\n    // Set up datasets.\n    this.populateDatasets();\n\n    this.querySelector('#dataset-dropdown .dropdown-content')!.addEventListener(\n        // tslint:disable-next-line:no-any\n        'iron-activate', (event: any) => {\n          // Update the dataset.\n          const datasetName = event.detail.selected;\n          this.updateSelectedDataset(datasetName);\n\n          // TODO(nsthorat): Remember the last model used for each dataset.\n          this.removeAllLayers();\n        });\n    this.querySelector('#model-dropdown .dropdown-content')!.addEventListener(\n        // tslint:disable-next-line:no-any\n        'iron-activate', (event: any) => {\n          // Update the model.\n          const modelName = event.detail.selected;\n          this.updateSelectedModel(modelName);\n        });\n\n    {\n      const normalizationDropdown =\n          this.querySelector('#normalization-dropdown .dropdown-content')!;\n      // tslint:disable-next-line:no-any\n      normalizationDropdown.addEventListener('iron-activate', (event: any) => {\n        const selectedNormalizationOption = event.detail.selected;\n        this.applyNormalization(selectedNormalizationOption);\n        this.setupDatasetStats();\n      });\n    }\n\n    this.applicationState = ApplicationState.IDLE;\n    this.loadedWeights = null;\n    this.modelInitialized = false;\n    this.showTrainStats = false;\n    this.showDatasetStats = false;\n\n    const addButton = this.querySelector('#add-layer')!;\n    addButton.addEventListener('click', () => this.addLayer());\n\n    const downloadModelButton = this.querySelector('#download-model')!;\n    downloadModelButton.addEventListener('click', () => this.downloadModel());\n    const uploadModelButton = this.querySelector('#upload-model')!;\n    uploadModelButton.addEventListener('click', () => this.uploadModel());\n    this.setupUploadModelButton();\n\n    const uploadWeightsButton = this.querySelector('#upload-weights')!;\n    uploadWeightsButton.addEventListener('click', () => this.uploadWeights());\n    this.setupUploadWeightsButton();\n\n    const stopButton = this.querySelector('#stop')!;\n    stopButton.addEventListener('click', () => {\n      this.applicationState = ApplicationState.IDLE;\n      this.graphRunner.stopTraining();\n    });\n\n    this.trainButton = this.querySelector('#train') as HTMLButtonElement;\n    this.trainButton.addEventListener('click', () => {\n      this.createModel();\n      this.startTraining();\n    });\n\n    this.querySelector(\n            '#environment-toggle')!.addEventListener('change', (event) => {\n      // tslint:disable-next-line:no-any\n      this.math = (event.target as any).active ? this.mathGPU : this.mathCPU;\n      this.graphRunner.setMath(this.math);\n    });\n\n    this.hiddenLayers = [];\n    this.examplesPerSec = 0;\n    this.inferencesPerSec = 0;\n  }\n\n  isTraining(applicationState: ApplicationState): boolean {\n    return applicationState === ApplicationState.TRAINING;\n  }\n\n  isIdle(applicationState: ApplicationState): boolean {\n    return applicationState === ApplicationState.IDLE;\n  }\n\n  private getTestData(): NDArray[][] {\n    const data = this.dataSet.getData();\n    if (data == null) {\n      return null;\n    }\n    const [images, labels] = this.dataSet.getData() as [NDArray[], NDArray[]];\n\n    const start = Math.floor(TRAIN_TEST_RATIO * images.length);\n\n    return [images.slice(start), labels.slice(start)];\n  }\n\n  private getTrainingData(): NDArray[][] {\n    const [images, labels] = this.dataSet.getData() as [NDArray[], NDArray[]];\n\n    const end = Math.floor(TRAIN_TEST_RATIO * images.length);\n\n    return [images.slice(0, end), labels.slice(0, end)];\n  }\n\n  private startInference() {\n    const testData = this.getTestData();\n    if (testData == null) {\n      // Dataset not ready yet.\n      return;\n    }\n    if (this.isValid && (testData != null)) {\n      const inferenceShuffledInputProviderGenerator =\n          new InCPUMemoryShuffledInputProviderBuilder(testData);\n      const [inferenceInputProvider, inferenceLabelProvider] =\n          inferenceShuffledInputProviderGenerator.getInputProviders();\n\n      const inferenceFeeds = [\n        {tensor: this.xTensor, data: inferenceInputProvider},\n        {tensor: this.labelTensor, data: inferenceLabelProvider}\n      ];\n\n      this.graphRunner.infer(\n          this.predictionTensor, inferenceFeeds, INFERENCE_EXAMPLE_INTERVAL_MS,\n          INFERENCE_EXAMPLE_COUNT);\n    }\n  }\n\n  private startTraining() {\n    const trainingData = this.getTrainingData();\n    const testData = this.getTestData();\n\n    if (this.isValid && (trainingData != null) && (testData != null)) {\n      this.recreateCharts();\n      this.graphRunner.resetStatistics();\n\n      const trainingShuffledInputProviderGenerator =\n          new InCPUMemoryShuffledInputProviderBuilder(trainingData);\n      const [trainInputProvider, trainLabelProvider] =\n          trainingShuffledInputProviderGenerator.getInputProviders();\n\n      const trainFeeds = [\n        {tensor: this.xTensor, data: trainInputProvider},\n        {tensor: this.labelTensor, data: trainLabelProvider}\n      ];\n\n      const accuracyShuffledInputProviderGenerator =\n          new InCPUMemoryShuffledInputProviderBuilder(testData);\n      const [accuracyInputProvider, accuracyLabelProvider] =\n          accuracyShuffledInputProviderGenerator.getInputProviders();\n\n      const accuracyFeeds = [\n        {tensor: this.xTensor, data: accuracyInputProvider},\n        {tensor: this.labelTensor, data: accuracyLabelProvider}\n      ];\n\n      this.graphRunner.train(\n          this.costTensor, trainFeeds, BATCH_SIZE, this.optimizer,\n          undefined /** numBatches */, this.accuracyTensor, accuracyFeeds,\n          BATCH_SIZE, MetricReduction.MEAN, EVAL_INTERVAL_MS, COST_INTERVAL_MS);\n\n      this.showTrainStats = true;\n      this.applicationState = ApplicationState.TRAINING;\n    }\n  }\n\n  private createModel() {\n    if (this.session != null) {\n      this.session.dispose();\n    }\n\n    this.modelInitialized = false;\n    if (this.isValid === false) {\n      return;\n    }\n\n    this.graph = new Graph();\n    const g = this.graph;\n    this.xTensor = g.placeholder('input', this.inputShape);\n    this.labelTensor = g.placeholder('label', this.labelShape);\n\n    let network = this.xTensor;\n\n    for (let i = 0; i < this.hiddenLayers.length; i++) {\n      let weights: LayerWeightsDict|null = null;\n      if (this.loadedWeights != null) {\n        weights = this.loadedWeights[i];\n      }\n      network = this.hiddenLayers[i].addLayer(g, network, i, weights);\n    }\n    this.predictionTensor = network;\n    this.costTensor =\n        g.softmaxCrossEntropyCost(this.predictionTensor, this.labelTensor);\n    this.accuracyTensor =\n        g.argmaxEquals(this.predictionTensor, this.labelTensor);\n\n    this.loadedWeights = null;\n\n    this.session = new Session(g, this.math);\n    this.graphRunner.setSession(this.session);\n\n    this.startInference();\n\n    this.modelInitialized = true;\n  }\n\n  private populateDatasets() {\n    this.dataSets = {};\n    xhr_dataset.getXhrDatasetConfig(DATASETS_CONFIG_JSON)\n        .then(\n            xhrDatasetConfigs => {\n              for (const datasetName in xhrDatasetConfigs) {\n                if (xhrDatasetConfigs.hasOwnProperty(datasetName)) {\n                  this.dataSets[datasetName] =\n                      new XhrDataset(xhrDatasetConfigs[datasetName]);\n                }\n              }\n              this.datasetNames = Object.keys(this.dataSets);\n              this.selectedDatasetName = this.datasetNames[0];\n              this.xhrDatasetConfigs = xhrDatasetConfigs;\n              this.updateSelectedDataset(this.datasetNames[0]);\n            },\n            error => {\n              throw new Error('Dataset config could not be loaded: ' + error);\n            });\n  }\n\n  private updateSelectedDataset(datasetName: string) {\n    this.graphRunner.stopTraining();\n    this.graphRunner.stopInferring();\n\n    if (this.dataSet != null) {\n      this.dataSet.dispose();\n    }\n\n    this.selectedDatasetName = datasetName;\n    this.dataSet = this.dataSets[datasetName];\n    this.datasetDownloaded = false;\n    this.showDatasetStats = false;\n\n    this.dataSet.fetchData().then(() => {\n      this.datasetDownloaded = true;\n      this.applyNormalization(this.selectedNormalizationOption);\n      this.setupDatasetStats();\n      if (this.isValid) {\n        this.createModel();\n        this.startInference();\n      }\n    });\n    // Get prebuilt models.\n    this.populateModelDropdown();\n\n    this.inputShape = this.dataSet.getDataShape(IMAGE_DATA_INDEX);\n    this.labelShape = this.dataSet.getDataShape(LABEL_DATA_INDEX);\n\n    this.layersContainer =\n        this.querySelector('#hidden-layers') as HTMLDivElement;\n\n    this.inputLayer = this.querySelector('#input-layer') as ModelLayer;\n    this.inputLayer.outputShapeDisplay =\n        model_builder_util.getDisplayShape(this.inputShape);\n\n    const labelShapeDisplay =\n        model_builder_util.getDisplayShape(this.labelShape);\n    const costLayer = this.querySelector('#cost-layer') as ModelLayer;\n    costLayer.inputShapeDisplay = labelShapeDisplay;\n    costLayer.outputShapeDisplay = labelShapeDisplay;\n\n    const outputLayer = this.querySelector('#output-layer') as ModelLayer;\n    outputLayer.inputShapeDisplay = labelShapeDisplay;\n\n    // Setup the inference example container.\n    // TODO(nsthorat): Generalize this.\n    const inferenceContainer =\n        this.querySelector('#inference-container') as HTMLElement;\n    inferenceContainer.innerHTML = '';\n    this.inputNDArrayVisualizers = [];\n    this.outputNDArrayVisualizers = [];\n    for (let i = 0; i < INFERENCE_EXAMPLE_COUNT; i++) {\n      const inferenceExampleElement = document.createElement('div');\n      inferenceExampleElement.className = 'inference-example';\n\n      // Set up the input visualizer.\n      const ndarrayImageVisualizer =\n          document.createElement('ndarray-image-visualizer') as\n          NDArrayImageVisualizer;\n      ndarrayImageVisualizer.setShape(this.inputShape);\n      ndarrayImageVisualizer.setSize(\n          INFERENCE_IMAGE_SIZE_PX, INFERENCE_IMAGE_SIZE_PX);\n      this.inputNDArrayVisualizers.push(ndarrayImageVisualizer);\n      inferenceExampleElement.appendChild(ndarrayImageVisualizer);\n\n      // Set up the output ndarray visualizer.\n      const ndarrayLogitsVisualizer =\n          document.createElement('ndarray-logits-visualizer') as\n          NDArrayLogitsVisualizer;\n      ndarrayLogitsVisualizer.initialize(\n          INFERENCE_IMAGE_SIZE_PX, INFERENCE_IMAGE_SIZE_PX);\n      this.outputNDArrayVisualizers.push(ndarrayLogitsVisualizer);\n      inferenceExampleElement.appendChild(ndarrayLogitsVisualizer);\n\n      inferenceContainer.appendChild(inferenceExampleElement);\n    }\n  }\n\n  private populateModelDropdown() {\n    const modelNames = ['Custom'];\n\n    const modelConfigs =\n        this.xhrDatasetConfigs[this.selectedDatasetName].modelConfigs;\n    for (const modelName in modelConfigs) {\n      if (modelConfigs.hasOwnProperty(modelName)) {\n        modelNames.push(modelName);\n      }\n    }\n\n    this.modelNames = modelNames;\n    this.selectedModelName = modelNames[modelNames.length - 1];\n    this.updateSelectedModel(this.selectedModelName);\n  }\n\n  private updateSelectedModel(modelName: string) {\n    this.removeAllLayers();\n    if (modelName === 'Custom') {\n      // TODO(nsthorat): Remember the custom layers.\n      return;\n    }\n\n    this.loadModelFromPath(this.xhrDatasetConfigs[this.selectedDatasetName]\n                               .modelConfigs[modelName]\n                               .path);\n  }\n\n  private loadModelFromPath(modelPath: string) {\n    const xhr = new XMLHttpRequest();\n    xhr.open('GET', modelPath);\n\n    xhr.onload = () => {\n      this.loadModelFromJson(xhr.responseText);\n    };\n    xhr.onerror = (error) => {\n      throw new Error(\n          'Model could not be fetched from ' + modelPath + ': ' + error);\n    };\n    xhr.send();\n  }\n\n  private setupDatasetStats() {\n    this.datasetStats = this.dataSet.getStats();\n    this.statsExampleCount = this.datasetStats[IMAGE_DATA_INDEX].exampleCount;\n    this.statsInputRange = '[' + this.datasetStats[IMAGE_DATA_INDEX].inputMin +\n        ', ' + this.datasetStats[IMAGE_DATA_INDEX].inputMax + ']';\n    this.statsInputShapeDisplay = model_builder_util.getDisplayShape(\n        this.datasetStats[IMAGE_DATA_INDEX].shape);\n    this.statsLabelShapeDisplay = model_builder_util.getDisplayShape(\n        this.datasetStats[LABEL_DATA_INDEX].shape);\n    this.showDatasetStats = true;\n  }\n\n  private applyNormalization(selectedNormalizationOption: number) {\n    switch (selectedNormalizationOption) {\n      case Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE: {\n        this.dataSet.normalizeWithinBounds(IMAGE_DATA_INDEX, -1, 1);\n        break;\n      }\n      case Normalization.NORMALIZATION_ZERO_TO_ONE: {\n        this.dataSet.normalizeWithinBounds(IMAGE_DATA_INDEX, 0, 1);\n        break;\n      }\n      case Normalization.NORMALIZATION_NONE: {\n        this.dataSet.removeNormalization(IMAGE_DATA_INDEX);\n        break;\n      }\n      default: { throw new Error('Normalization option must be 0, 1, or 2'); }\n    }\n    this.setupDatasetStats();\n  }\n\n  private recreateCharts() {\n    this.costChartData = [];\n    if (this.costChart != null) {\n      this.costChart.destroy();\n    }\n    this.costChart =\n        this.createChart('cost-chart', 'Cost', this.costChartData, 0);\n\n    if (this.accuracyChart != null) {\n      this.accuracyChart.destroy();\n    }\n    this.accuracyChartData = [];\n    this.accuracyChart = this.createChart(\n        'accuracy-chart', 'Accuracy', this.accuracyChartData, 0, 100);\n\n    if (this.examplesPerSecChart != null) {\n      this.examplesPerSecChart.destroy();\n    }\n    this.examplesPerSecChartData = [];\n    this.examplesPerSecChart = this.createChart(\n        'examplespersec-chart', 'Examples/sec', this.examplesPerSecChartData,\n        0);\n  }\n\n  private createChart(\n      canvasId: string, label: string, data: ChartData[], min?: number,\n      max?: number): Chart {\n    const context = (document.getElementById(canvasId) as HTMLCanvasElement)\n                        .getContext('2d') as CanvasRenderingContext2D;\n    return new Chart(context, {\n      type: 'line',\n      data: {\n        datasets: [{\n          data,\n          fill: false,\n          label,\n          pointRadius: 0,\n          borderColor: 'rgba(75,192,192,1)',\n          borderWidth: 1,\n          lineTension: 0,\n          pointHitRadius: 8\n        }]\n      },\n      options: {\n        animation: {duration: 0},\n        responsive: false,\n        scales: {\n          xAxes: [{type: 'linear', position: 'bottom'}],\n          yAxes: [{\n            ticks: {\n              max,\n              min,\n            }\n          }]\n        }\n      }\n    });\n  }\n\n  displayBatchesTrained(totalBatchesTrained: number) {\n    this.examplesTrained = BATCH_SIZE * totalBatchesTrained;\n  }\n\n  displayCost(avgCost: Scalar) {\n    this.costChartData.push(\n        {x: this.graphRunner.getTotalBatchesTrained(), y: avgCost.get()});\n    this.costChart.update();\n  }\n\n  displayAccuracy(accuracy: Scalar) {\n    this.accuracyChartData.push({\n      x: this.graphRunner.getTotalBatchesTrained(),\n      y: accuracy.get() * 100\n    });\n    this.accuracyChart.update();\n  }\n\n  displayInferenceExamplesPerSec(examplesPerSec: number) {\n    this.inferencesPerSec =\n        this.smoothExamplesPerSec(this.inferencesPerSec, examplesPerSec);\n    this.inferenceDuration = Number((1000 / examplesPerSec).toPrecision(3));\n  }\n\n  displayExamplesPerSec(examplesPerSec: number) {\n    this.examplesPerSecChartData.push(\n        {x: this.graphRunner.getTotalBatchesTrained(), y: examplesPerSec});\n    this.examplesPerSecChart.update();\n    this.examplesPerSec =\n        this.smoothExamplesPerSec(this.examplesPerSec, examplesPerSec);\n  }\n\n  private smoothExamplesPerSec(\n      lastExamplesPerSec: number, nextExamplesPerSec: number): number {\n    return Number((EXAMPLE_SEC_STAT_SMOOTHING_FACTOR * lastExamplesPerSec +\n                   (1 - EXAMPLE_SEC_STAT_SMOOTHING_FACTOR) * nextExamplesPerSec)\n                      .toPrecision(3));\n  }\n\n  displayInferenceExamplesOutput(\n      inputFeeds: FeedEntry[][], inferenceOutputs: NDArray[]) {\n    let images: Array3D[] = [];\n    const logits: Array1D[] = [];\n    const labels: Array1D[] = [];\n    for (let i = 0; i < inputFeeds.length; i++) {\n      images.push(inputFeeds[i][IMAGE_DATA_INDEX].data as Array3D);\n      labels.push(inputFeeds[i][LABEL_DATA_INDEX].data as Array1D);\n      logits.push(inferenceOutputs[i] as Array1D);\n    }\n\n    images =\n        this.dataSet.unnormalizeExamples(images, IMAGE_DATA_INDEX) as Array3D[];\n\n    // Draw the images.\n    for (let i = 0; i < inputFeeds.length; i++) {\n      this.inputNDArrayVisualizers[i].saveImageDataFromNDArray(images[i]);\n    }\n\n    // Draw the logits.\n    for (let i = 0; i < inputFeeds.length; i++) {\n      const softmaxLogits = this.math.softmax(logits[i]);\n\n      this.outputNDArrayVisualizers[i].drawLogits(\n          softmaxLogits, labels[i],\n          this.xhrDatasetConfigs[this.selectedDatasetName].labelClassNames);\n      this.inputNDArrayVisualizers[i].draw();\n\n      softmaxLogits.dispose();\n    }\n  }\n\n  addLayer(): ModelLayer {\n    const modelLayer = document.createElement('model-layer') as ModelLayer;\n    modelLayer.className = 'layer';\n    this.layersContainer.appendChild(modelLayer);\n\n    const lastHiddenLayer = this.hiddenLayers[this.hiddenLayers.length - 1];\n    const lastOutputShape = lastHiddenLayer != null ?\n        lastHiddenLayer.getOutputShape() :\n        this.inputShape;\n    this.hiddenLayers.push(modelLayer);\n    modelLayer.initialize(this, lastOutputShape);\n    return modelLayer;\n  }\n\n  removeLayer(modelLayer: ModelLayer) {\n    this.layersContainer.removeChild(modelLayer);\n    this.hiddenLayers.splice(this.hiddenLayers.indexOf(modelLayer), 1);\n    this.layerParamChanged();\n  }\n\n  private removeAllLayers() {\n    for (let i = 0; i < this.hiddenLayers.length; i++) {\n      this.layersContainer.removeChild(this.hiddenLayers[i]);\n    }\n    this.hiddenLayers = [];\n    this.layerParamChanged();\n  }\n\n  private validateModel() {\n    let valid = true;\n    for (let i = 0; i < this.hiddenLayers.length; ++i) {\n      valid = valid && this.hiddenLayers[i].isValid();\n    }\n    if (this.hiddenLayers.length > 0) {\n      const lastLayer = this.hiddenLayers[this.hiddenLayers.length - 1];\n      valid = valid &&\n          util.arraysEqual(this.labelShape, lastLayer.getOutputShape());\n    }\n    this.isValid = valid && (this.hiddenLayers.length > 0);\n  }\n\n  layerParamChanged() {\n    // Go through each of the model layers and propagate shapes.\n    let lastOutputShape = this.inputShape;\n    for (let i = 0; i < this.hiddenLayers.length; i++) {\n      lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape);\n    }\n    this.validateModel();\n\n    if (this.isValid) {\n      this.createModel();\n      this.startInference();\n    }\n  }\n\n  private downloadModel() {\n    const modelJson = this.getModelAsJson();\n    const blob = new Blob([modelJson], {type: 'text/json'});\n    const textFile = window.URL.createObjectURL(blob);\n\n    // Force a download.\n    const a = document.createElement('a');\n    document.body.appendChild(a);\n    a.style.display = 'none';\n    a.href = textFile;\n    // tslint:disable-next-line:no-any\n    (a as any).download = this.selectedDatasetName + '_model';\n    a.click();\n\n    document.body.removeChild(a);\n    window.URL.revokeObjectURL(textFile);\n  }\n\n  private uploadModel() {\n    (this.querySelector('#model-file') as HTMLInputElement).click();\n  }\n\n  private setupUploadModelButton() {\n    // Show and setup the load view button.\n    const fileInput = this.querySelector('#model-file') as HTMLInputElement;\n    fileInput.addEventListener('change', event => {\n      const file = fileInput.files![0];\n      // Clear out the value of the file chooser. This ensures that if the user\n      // selects the same file, we'll re-read it.\n      fileInput.value = '';\n      const fileReader = new FileReader();\n      fileReader.onload = (evt) => {\n        this.removeAllLayers();\n        const modelJson: string = fileReader.result;\n        this.loadModelFromJson(modelJson);\n      };\n      fileReader.readAsText(file);\n    });\n  }\n\n  private getModelAsJson(): string {\n    const layerBuilders: LayerBuilder[] = [];\n    for (let i = 0; i < this.hiddenLayers.length; i++) {\n      layerBuilders.push(this.hiddenLayers[i].layerBuilder);\n    }\n    return JSON.stringify(layerBuilders);\n  }\n\n  private loadModelFromJson(modelJson: string) {\n    let lastOutputShape = this.inputShape;\n\n    const layerBuilders = JSON.parse(modelJson) as LayerBuilder[];\n    for (let i = 0; i < layerBuilders.length; i++) {\n      const modelLayer = this.addLayer();\n      modelLayer.loadParamsFromLayerBuilder(lastOutputShape, layerBuilders[i]);\n      lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape);\n    }\n    this.validateModel();\n  }\n\n  private uploadWeights() {\n    (this.querySelector('#weights-file') as HTMLInputElement).click();\n  }\n\n  private setupUploadWeightsButton() {\n    // Show and setup the load view button.\n    const fileInput = this.querySelector('#weights-file') as HTMLInputElement;\n    fileInput.addEventListener('change', event => {\n      const file = fileInput.files![0];\n      // Clear out the value of the file chooser. This ensures that if the user\n      // selects the same file, we'll re-read it.\n      fileInput.value = '';\n      const fileReader = new FileReader();\n      fileReader.onload = (evt) => {\n        const weightsJson: string = fileReader.result;\n        this.loadWeightsFromJson(weightsJson);\n        this.createModel();\n        this.startInference();\n      };\n      fileReader.readAsText(file);\n    });\n  }\n\n  private loadWeightsFromJson(weightsJson: string) {\n    this.loadedWeights = JSON.parse(weightsJson) as LayerWeightsDict[];\n  }\n}\n\ndocument.registerElement(ModelBuilder.prototype.is, ModelBuilder);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Tensor} from '../learnjs';\n// tslint:disable-next-line:no-unused-variable\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\n\nimport * as layer_builder from './layer_builder';\nimport {LayerBuilder, LayerName, LayerWeightsDict} from './layer_builder';\nimport {ModelBuilder} from './model-builder';\nimport * as model_builder_util from './model_builder_util';\n\n// tslint:disable-next-line:variable-name\nexport let ModelLayerPolymer = PolymerElement({\n  is: 'model-layer',\n  properties: {\n    layerName: String,\n    inputShapeDisplay: String,\n    outputShapeDisplay: String,\n    isStatic: {type: Boolean, value: false},\n    layerNames: Array,\n    selectedLayerName: String,\n    hasError: {type: Boolean, value: false},\n    errorMessages: Array,\n  }\n});\n\nexport class ModelLayer extends ModelLayerPolymer {\n  // Polymer properties.\n  inputShapeDisplay: string;\n  outputShapeDisplay: string;\n  private layerNames: LayerName[];\n  private selectedLayerName: LayerName;\n  private hasError: boolean;\n  private errorMessages: string[];\n\n  private modelBuilder: ModelBuilder;\n  layerBuilder: LayerBuilder;\n  private inputShape: number[];\n  private outputShape: number[];\n\n  private paramContainer: HTMLDivElement;\n\n  initialize(modelBuilder: ModelBuilder, inputShape: number[]) {\n    this.modelBuilder = modelBuilder;\n    this.paramContainer =\n        this.querySelector('.param-container') as HTMLDivElement;\n    this.layerNames = [\n      'Fully connected', 'ReLU', 'Convolution', 'Max pool', 'Reshape', 'Flatten'\n    ];\n    this.inputShape = inputShape;\n    this.buildParamsUI('Fully connected', this.inputShape);\n\n    this.querySelector('.dropdown-content')!.addEventListener(\n        // tslint:disable-next-line:no-any\n        'iron-activate', (event: any) => {\n          this.buildParamsUI(\n              event.detail.selected as LayerName, this.inputShape);\n        });\n\n    this.querySelector('#remove-layer')!.addEventListener('click', (event) => {\n      modelBuilder.removeLayer(this);\n    });\n  }\n\n  setInputShape(shape: number[]): number[] {\n    this.inputShape = shape;\n    this.inputShapeDisplay =\n        model_builder_util.getDisplayShape(this.inputShape);\n\n    const errors: string[] = [];\n    const validationErrors = this.layerBuilder.validate(this.inputShape);\n    if (validationErrors != null) {\n      for (let i = 0; i < validationErrors.length; i++) {\n        errors.push('Error: ' + validationErrors[i]);\n      }\n    }\n\n    try {\n      this.outputShape = this.layerBuilder.getOutputShape(this.inputShape);\n    } catch (e) {\n      errors.push(e);\n    }\n    this.outputShapeDisplay =\n        model_builder_util.getDisplayShape(this.outputShape);\n\n    if (errors.length > 0) {\n      this.hasError = true;\n      this.errorMessages = errors;\n    } else {\n      this.hasError = false;\n      this.errorMessages = [];\n    }\n\n    return this.outputShape;\n  }\n\n  isValid(): boolean {\n    return !this.hasError;\n  }\n\n  getOutputShape(): number[] {\n    return this.outputShape;\n  }\n\n  addLayer(\n      g: Graph, network: Tensor, index: number,\n      weights: LayerWeightsDict|null): Tensor {\n    return this.layerBuilder.addLayer(\n        g, network, this.inputShape, index, weights);\n  }\n\n  /**\n   * Build parameters for the UI for a given op type. This is called when the\n   * op is added, and when the op type changes.\n   */\n  buildParamsUI(\n      layerName: LayerName, inputShape: number[],\n      layerBuilderJson?: LayerBuilder) {\n    this.selectedLayerName = layerName;\n\n    this.layerBuilder =\n        layer_builder.getLayerBuilder(layerName, layerBuilderJson);\n\n    // Clear any existing parameters.\n    this.paramContainer.innerHTML = '';\n\n    // Add all the parameters to the UI.\n    const layerParams = this.layerBuilder.getLayerParams();\n    for (let i = 0; i < layerParams.length; i++) {\n      const initialValue = layerBuilderJson != null ?\n          layerParams[i].getValue() :\n          layerParams[i].initialValue(inputShape);\n      this.addParamField(\n          layerParams[i].label, initialValue, layerParams[i].setValue,\n          layerParams[i].type, layerParams[i].min, layerParams[i].max);\n    }\n    this.modelBuilder.layerParamChanged();\n  }\n\n  loadParamsFromLayerBuilder(\n      inputShape: number[], layerBuilderJson: LayerBuilder) {\n    this.buildParamsUI(\n        layerBuilderJson.layerName, inputShape, layerBuilderJson);\n  }\n\n  private addParamField(\n      label: string, initialValue: number|string,\n      setValue: (value: number|string) => void, type: 'number'|'text',\n      min?: number, max?: number) {\n    const input = document.createElement('paper-input');\n    input.setAttribute('always-float-label', 'true');\n    input.setAttribute('label', label);\n    input.setAttribute('value', '' + initialValue);\n    input.setAttribute('type', type);\n    if (type === 'number') {\n      input.setAttribute('min', '' + min);\n      input.setAttribute('max', '' + max);\n    }\n    input.className = 'param-input';\n    this.paramContainer.appendChild(input);\n\n    // Update the parent when this changes.\n    input.addEventListener('input', (event) => {\n      if (type === 'number') {\n        // tslint:disable-next-line:no-any\n        setValue((event.target as any).valueAsNumber as number);\n      } else {\n        // tslint:disable-next-line:no-any\n        setValue((event.target as any).value as string);\n      }\n      this.modelBuilder.layerParamChanged();\n    });\n    setValue(initialValue);\n  }\n}\n\ndocument.registerElement(ModelLayer.prototype.is, ModelLayer);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getDisplayShape(shape: number[]) {\n  return '[' + shape + ']';\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Convolution2DLayerBuilder, LayerBuilder, MaxPoolLayerBuilder} from './layer_builder';\n\nexport enum Normalization {\n  NORMALIZATION_NEGATIVE_ONE_TO_ONE,\n  NORMALIZATION_ZERO_TO_ONE,\n  NORMALIZATION_NONE\n}\n\nexport function generatePython(\n    datasetName: string, normalizationStrategy: number, inputShape: number[],\n    modelLayers: LayerBuilder[]): string {\n  const loadData = generateLoadData(datasetName, normalizationStrategy);\n  const buildModel = generateBuildModel(inputShape, modelLayers);\n  const captureWeights = generateCaptureWeights(modelLayers);\n  return [loadData, buildModel, captureWeights].join('\\n\\n');\n}\n\nfunction generateLoadData(\n    datasetName: string, normalizationStrategy: number): string {\n  let loadFunction: string;\n  switch (datasetName) {\n    case 'CIFAR 10': {\n      loadFunction = 'cifar10';\n      break;\n    }\n    case 'MNIST': {\n      loadFunction = 'mnist';\n      break;\n    }\n    default: {\n      throw new Error('datasetName must be \\'CIFAR 10\\' or \\'MNIST\\'');\n    }\n  }\n\n  let normString: string;\n  switch (normalizationStrategy) {\n    case Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE: {\n      normString = 'NORMALIZATION_NEGATIVE_ONE_TO_ONE';\n      break;\n    }\n    case Normalization.NORMALIZATION_ZERO_TO_ONE: {\n      normString = 'NORMALIZATION_ZERO_TO_ONE';\n      break;\n    }\n    case Normalization.NORMALIZATION_NONE: {\n      normString = 'NORMALIZATION_NONE';\n      break;\n    }\n    default: { throw new Error('invalid normalizationStrategy value'); }\n  }\n\n  return `def load_data():\n  return learnjs_colab.load_${loadFunction}(learnjs_colab.${normString})\n`;\n}\n\nfunction generateBuildModelLayer(\n    layerIndex: number, inputShape: number[], layer: LayerBuilder): string {\n  let src = '';\n  const W = 'W_' + layerIndex;\n  const b = 'b_' + layerIndex;\n  const outputShape = layer.getOutputShape(inputShape);\n  switch (layer.layerName) {\n    case 'Fully connected': {\n      const shape = [inputShape[0], outputShape].join(', ');\n\n      src = `  ${W} = tf.Variable(tf.truncated_normal([${shape}],\n                    stddev = 1.0 / math.sqrt(${outputShape[0]})))\n  ${b} = tf.Variable(tf.truncated_normal([${outputShape[0]}], stddev = 0.1))\n  layers.append({ 'x': layers[-1]['y'],\n                  'W': ${W},\n                  'b': ${b},\n                  'y': tf.add(tf.matmul(layers[-1]['y'], ${W}), ${b}) })`;\n      break;\n    }\n\n    case 'ReLU': {\n      src = `  layers.append({ 'x': layers[-1]['y'],\n                  'y': tf.nn.relu(layers[-1]['y']) })`;\n      break;\n    }\n\n    case 'Convolution': {\n      const conv = layer as Convolution2DLayerBuilder;\n      const f = conv.fieldSize;\n      const d1 = inputShape[inputShape.length - 1];\n      const d2 = outputShape[outputShape.length - 1];\n      const wShape = '[' + f + ', ' + f + ', ' + d1 + ', ' + d2 + ']';\n      const stride = '[1, ' + conv.stride + ', ' + conv.stride + ', 1]';\n      src = `  ${W} = tf.Variable(tf.truncated_normal(${wShape}, stddev = 0.1))\n  ${b} = tf.Variable(tf.truncated_normal([${d2}], stddev = 0.1))\n  layers.append({ 'x': layers[-1]['y'],\n                  'W': ${W},\n                  'b': ${b},\n                  'y': tf.add(tf.nn.conv2d(layers[-1]['y'],\n                                           ${W},\n                                           strides = ${stride},\n                                           padding = 'SAME'), ${b}) })`;\n      break;\n    }\n\n    case 'Max pool': {\n      const mp = layer as MaxPoolLayerBuilder;\n      const field = '[1, ' + mp.fieldSize + ', ' + mp.fieldSize + ', 1]';\n      const stride = '[1, ' + mp.stride + ', ' + mp.stride + ', 1]';\n      src = `  layers.append({ 'x': layers[-1]['y'],\n                  'y': tf.nn.max_pool(layers[-1]['y'],\n                                      ${field},\n                                      ${stride},\n                                      padding = 'SAME') })`;\n      break;\n    }\n\n    case 'Reshape': {\n      break;\n    }\n\n    case 'Flatten': {\n      src = `  layers.append({ 'x': layers[-1]['y'],\n                  'y': tf.reshape(layers[-1]['y'], [-1, ${outputShape[0]}]) })`;\n      break;\n    }\n\n    default: {\n      throw new Error('unknown layer type \\'' + layer.layerName + '\\'');\n    }\n  }\n\n  return src;\n}\n\nfunction generateBuildModel(\n    inputShape: number[], modelLayers: LayerBuilder[]): string {\n  const inputShapeStr = inputShape.join(', ');\n  const sources: string[] = [];\n\n  sources.push(`def build_model():\n  layers = []\n\n  layers.append({ 'y': tf.placeholder(tf.float32, [None, ${inputShapeStr}]),\n                  'y_label': tf.placeholder(tf.float32, [None, 10]) })`);\n\n  for (let i = 0; i < modelLayers.length; ++i) {\n    sources.push(generateBuildModelLayer(i + 1, inputShape, modelLayers[i]));\n    inputShape = modelLayers[i].getOutputShape(inputShape);\n  }\n\n  sources.push('  return layers\\n');\n  return sources.join('\\n\\n');\n}\n\nfunction generateCaptureWeights(modelLayers: LayerBuilder[]): string {\n  const sources: string[] = [];\n  sources.push(`def capture_weights():\n  weights = []`);\n\n  for (let i = 0; i < modelLayers.length; ++i) {\n    const layer = modelLayers[i];\n    const index = i + 1;\n    let src = '';\n    const W = '\\'W\\': model[' + index + '][\\'W\\']';\n    const b = '\\'b\\': model[' + index + '][\\'b\\']';\n    switch (layer.layerName) {\n      case 'Fully connected': {\n        src = `  weights.append({ ${W}.eval().flatten().tolist(),\n                   ${b}.eval().flatten().tolist() })`;\n        break;\n      }\n\n      case 'Convolution': {\n        src = `  weights.append({ ${W}.eval().transpose().flatten().tolist(),\n                   ${b}.eval().flatten().tolist() })`;\n        break;\n      }\n\n      default: { src = '  weights.append({})'; }\n    }\n\n    src += ' # ' + layer.layerName;\n    sources.push(src);\n  }\n\n  sources.push('  return weights');\n  return sources.join('\\n');\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// tslint:disable-next-line:no-unused-variable\nimport {Array3D} from '../src/math/ndarray';\n\nimport {PolymerElement, PolymerHTMLElement} from './polymer-spec';\n\n// tslint:disable-next-line\nexport let NDArrayImageVisualizerPolymer =\n    PolymerElement({is: 'ndarray-image-visualizer', properties: {}});\n\nexport class NDArrayImageVisualizer extends NDArrayImageVisualizerPolymer {\n  private canvas: HTMLCanvasElement;\n  private canvasContext: CanvasRenderingContext2D;\n  private imageData: ImageData;\n\n  ready() {\n    this.canvas = this.querySelector('#canvas') as HTMLCanvasElement;\n    this.canvas.width = 0;\n    this.canvas.height = 0;\n    this.canvasContext =\n        this.canvas.getContext('2d') as CanvasRenderingContext2D;\n    this.canvas.style.display = 'none';\n  }\n\n  setShape(shape: number[]) {\n    this.canvas.width = shape[1];\n    this.canvas.height = shape[0];\n  }\n\n  setSize(width: number, height: number) {\n    this.canvas.style.width = width + 'px';\n    this.canvas.style.height = height + 'px';\n  }\n\n  saveImageDataFromNDArray(ndarray: Array3D) {\n    this.imageData = this.canvasContext.createImageData(\n        this.canvas.width, this.canvas.height);\n    if (ndarray.shape[2] === 1) {\n      this.drawGrayscaleImageData(ndarray);\n    } else if (ndarray.shape[2] === 3) {\n      this.drawRGBImageData(ndarray);\n    }\n  }\n\n  drawRGBImageData(ndarray: Array3D) {\n    let pixelOffset = 0;\n    for (let i = 0; i < ndarray.shape[0]; i++) {\n      for (let j = 0; j < ndarray.shape[1]; j++) {\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 0);\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 1);\n        this.imageData.data[pixelOffset++] = ndarray.get(i, j, 2);\n        this.imageData.data[pixelOffset++] = 255;\n      }\n    }\n  }\n\n  drawGrayscaleImageData(ndarray: Array3D) {\n    let pixelOffset = 0;\n    for (let i = 0; i < ndarray.shape[0]; i++) {\n      for (let j = 0; j < ndarray.shape[1]; j++) {\n        const value = ndarray.get(i, j, 0);\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = value;\n        this.imageData.data[pixelOffset++] = 255;\n      }\n    }\n  }\n\n  draw() {\n    this.canvas.style.display = '';\n    this.canvasContext.putImageData(this.imageData, 0, 0);\n  }\n}\ndocument.registerElement(\n    NDArrayImageVisualizer.prototype.is, NDArrayImageVisualizer);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// tslint:disable-next-line:no-unused-variable\nimport {NDArrayMathCPU} from '../src/math/math_cpu';\nimport {Array1D} from '../src/math/ndarray';\n\nimport {PolymerElement, PolymerHTMLElement} from './polymer-spec';\n\nconst TOP_K = 3;\n\n// tslint:disable-next-line\nexport let NDArrayLogitsVisualizerPolymer =\n    PolymerElement({is: 'ndarray-logits-visualizer', properties: {}});\n\nexport class NDArrayLogitsVisualizer extends NDArrayLogitsVisualizerPolymer {\n  private logitLabelElements: HTMLElement[];\n  private logitVizElements: HTMLElement[];\n  private width: number;\n\n  initialize(width: number, height: number) {\n    this.width = width;\n    this.logitLabelElements = [];\n    this.logitVizElements = [];\n    const container = this.querySelector('.logits-container') as HTMLElement;\n    container.style.height = height + 'px';\n\n    for (let i = 0; i < TOP_K; i++) {\n      const logitContainer = document.createElement('div');\n      logitContainer.style.height = height / (TOP_K + 1) + 'px';\n      logitContainer.style.margin =\n          height / ((2 * TOP_K) * (TOP_K + 1)) + 'px 0';\n      logitContainer.className =\n          'single-logit-container ndarray-logits-visualizer';\n\n      const logitLabelElement = document.createElement('div');\n      logitLabelElement.className = 'logit-label ndarray-logits-visualizer';\n      this.logitLabelElements.push(logitLabelElement);\n\n      const logitVizOuterElement = document.createElement('div');\n      logitVizOuterElement.className =\n          'logit-viz-outer ndarray-logits-visualizer';\n\n      const logitVisInnerElement = document.createElement('div');\n      logitVisInnerElement.className =\n          'logit-viz-inner ndarray-logits-visualizer';\n      logitVisInnerElement.innerHTML = '&nbsp;';\n      logitVizOuterElement.appendChild(logitVisInnerElement);\n\n      this.logitVizElements.push(logitVisInnerElement);\n\n      logitContainer.appendChild(logitLabelElement);\n      logitContainer.appendChild(logitVizOuterElement);\n      container.appendChild(logitContainer);\n    }\n  }\n\n  drawLogits(\n      predictedLogits: Array1D, labelLogits: Array1D,\n      labelClassNames?: string[]) {\n    const mathCpu = new NDArrayMathCPU();\n    const labelClass = mathCpu.argMax(labelLogits).get();\n\n    const topk = mathCpu.topK(predictedLogits, TOP_K);\n    const topkIndices = topk.indices.getValues();\n    const topkValues = topk.values.getValues();\n\n    for (let i = 0; i < topkIndices.length; i++) {\n      const index = topkIndices[i];\n      this.logitLabelElements[i].innerText =\n          labelClassNames ? labelClassNames[index] : index + '';\n      this.logitLabelElements[i].style.width =\n          labelClassNames != null ? '100px' : '20px';\n      this.logitVizElements[i].style.backgroundColor = index === labelClass ?\n          'rgba(120, 185, 50, .84)' :\n          'rgba(220, 10, 10, 0.84)';\n      this.logitVizElements[i].style.width =\n          Math.floor(100 * topkValues[i]) + '%';\n      this.logitVizElements[i].innerText =\n          `${(100 * topkValues[i]).toFixed(1)}%`;\n    }\n  }\n}\n\ndocument.registerElement(\n    NDArrayLogitsVisualizer.prototype.is, NDArrayLogitsVisualizer);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * @fileoverview\n *\n * Defines an interface for creating Polymer elements in Typescript with the\n * correct typings. A Polymer element should be defined like this:\n *\n * ```\n * let MyElementPolymer = PolymerElement({\n *   is: 'my-polymer-element',\n *   properties: {\n *     foo: string,\n *     bar: Array\n *   }\n * });\n *\n * class MyElement extends MyElementPolymer {\n *   foo: string;\n *   bar: number[];\n *\n *   ready() {\n *     console.log('MyElement initialized!');\n *   }\n * }\n *\n * document.registerElement(MyElement.prototype.is, MyElement);\n * ```\n */\n\nexport type Spec = {\n  is: string; properties: {\n    [key: string]: (Function|{\n      // tslint:disable-next-line:no-any\n      type: Function, value?: any;\n      reflectToAttribute?: boolean;\n      readonly?: boolean;\n      notify?: boolean;\n      computed?: string;\n      observer?: string;\n    })\n  };\n  observers?: string[];\n};\n\nexport function PolymerElement(spec: Spec) {\n  // tslint:disable-next-line:no-any\n  return Polymer.Class(spec as any) as {new (): PolymerHTMLElement};\n}\n\nexport interface PolymerHTMLElement extends HTMLElement, polymer.Base {}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {InMemoryDataset} from '../src/dataset';\nimport {Array1D, NDArray} from '../src/math/ndarray';\nimport * as util from '../src/util';\n\nconst PARSING_IMAGE_CANVAS_HEIGHT_PX = 1000;\n\nexport interface NDArrayInfo {\n  path: string;\n  name: string;\n  dataType: 'uint8'|'float32'|'png';\n  shape: number[];\n}\n\nexport interface XhrDatasetConfig {\n  data: NDArrayInfo[];\n\n  labelClassNames?: string[];\n  // Paths to pre-built models.\n  modelConfigs: {[modelName: string]: XhrModelConfig};\n}\n\nexport interface XhrModelConfig {\n  path: string;\n}\n\nexport function getXhrDatasetConfig(jsonConfigPath: string):\n    Promise<{[datasetName: string]: XhrDatasetConfig}> {\n  return new Promise<{[datasetName: string]: XhrDatasetConfig}>(\n      (resolve, reject) => {\n        const xhr = new XMLHttpRequest();\n        xhr.open('GET', jsonConfigPath);\n\n        xhr.onload = () => {\n          resolve(JSON.parse(\n              xhr.responseText) as {[datasetName: string]: XhrDatasetConfig});\n        };\n        xhr.onerror = (error) => {\n          reject(error);\n        };\n        xhr.send();\n      });\n}\n\nexport class XhrDataset extends InMemoryDataset {\n  protected xhrDatasetConfig: XhrDatasetConfig;\n\n  constructor(xhrDatasetConfig: XhrDatasetConfig) {\n    super(xhrDatasetConfig.data.map(x => x.shape));\n    this.xhrDatasetConfig = xhrDatasetConfig;\n  }\n\n  protected getNDArray<T extends NDArray>(info: NDArrayInfo): Promise<T[]> {\n    const dataPromise = info.dataType === 'png' ?\n        parseTypedArrayFromPng(info, info.shape as [number, number, number]) :\n        parseTypedArrayFromBinary(info);\n\n    return dataPromise.then(data => {\n      const inputSize = util.sizeFromShape(info.shape);\n      const ndarrays: T[] = [];\n      for (let i = 0; i < data.length / inputSize; i++) {\n        const values = data.subarray(i * inputSize, (i + 1) * inputSize);\n        const ndarray =\n            NDArray.make<T>(info.shape, {values: new Float32Array(values)});\n        ndarrays.push(ndarray);\n      }\n      return ndarrays;\n    });\n  }\n\n  fetchData(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const promises = this.xhrDatasetConfig.data.map(x => this.getNDArray(x));\n      Promise.all(promises).then((data: NDArray[][]) => {\n        this.dataset = data;\n        resolve();\n      });\n    });\n  }\n}\n\nfunction parseTypedArrayFromBinary(info: NDArrayInfo):\n    Promise<Float32Array|Uint8Array> {\n  return new Promise<Float32Array|Uint8Array>((resolve, reject) => {\n    const xhr = new XMLHttpRequest();\n    xhr.open('GET', info.path);\n    xhr.responseType = 'arraybuffer';\n    xhr.onload = event => {\n      const data = (info.dataType === 'float32') ?\n          new Float32Array(xhr.response) :\n          new Uint8Array(xhr.response);\n      resolve(data);\n    };\n    xhr.onerror = err => reject(err);\n    xhr.send();\n  });\n}\n\nfunction parseGrayscaleImageData(\n    data: Uint8Array|Uint8ClampedArray, result: Uint8Array,\n    resultOffset: number): void {\n  let idx = resultOffset;\n  for (let i = 0; i < data.length; i += 4) {\n    result[idx++] = data[i];\n  }\n}\n\nfunction parseRGBImageData(\n    data: Uint8Array|Uint8ClampedArray, result: Uint8Array,\n    resultOffset: number): void {\n  let idx = resultOffset;\n  for (let i = 0; i < data.length; i += 4) {\n    result[idx] = data[i];\n    result[idx + 1] = data[i + 1];\n    result[idx + 2] = data[i + 2];\n    idx += 3;\n  }\n}\n\nfunction parseImage(\n    img: HTMLImageElement, shape: [number, number, number]): Uint8Array {\n  const canvas = document.createElement('canvas');\n  const ctx = canvas.getContext('2d')!;\n  const N = img.height;\n  const inputSize = util.sizeFromShape(shape);\n  const result = new Uint8Array(N * inputSize);\n  if (img.width !== shape[0] * shape[1]) {\n    throw new Error(\n        `Image width (${img.width}) must be multiple of ` +\n        `rows*columns (${shape[0]}*${shape[1]}) of the ndarray`);\n  }\n  // TODO(smilkov): Canvas has max width of 32,767px. This approach\n  // (canvas.width = shape[0] * shape[1]) works with examples up to 181x181px.\n  // Consider having the canvas in un-flat format, i.e.\n  // canvas.width = shape[1]; canvas.height = DRAW_BATCH * shape[0];\n  canvas.width = img.width;\n\n  // Ideally we want canvas.height=img.height (which is N), but canvas size is\n  // limited by the browser, so we do multiple passes with a smaller canvas.\n  canvas.height = PARSING_IMAGE_CANVAS_HEIGHT_PX;\n  const sx = 0;\n  const sWidth = canvas.width;\n  let sHeight = canvas.height;\n  const dx = 0;\n  const dy = 0;\n  const dWidth = sWidth;\n  let dHeight = sHeight;\n  const depth = shape[2];\n  let offset = 0;\n  const numPasses = Math.ceil(N / canvas.height);\n  for (let pass = 0; pass < numPasses; ++pass) {\n    const sy = pass * canvas.height;\n    if ((pass === numPasses - 1) && (N % canvas.height > 0)) {\n      // Last pass is a special case.\n      canvas.height = N % canvas.height;\n      sHeight = canvas.height;\n      dHeight = sHeight;\n    }\n    ctx.drawImage(img, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);\n    const data = ctx.getImageData(0, 0, canvas.width, canvas.height).data;\n    (depth === 1) ? parseGrayscaleImageData(data, result, offset) :\n                    parseRGBImageData(data, result, offset);\n    offset += canvas.height * inputSize;\n  }\n  return result;\n}\n\nfunction parseTypedArrayFromPng(\n    info: NDArrayInfo, shape: [number, number, number]): Promise<Uint8Array> {\n  return new Promise<Uint8Array>((resolve, reject) => {\n    let img = new Image();\n    img.setAttribute('crossOrigin', '');\n    img.onload = () => {\n      const result = parseImage(img, shape);\n      img.src = '';\n      img = null!;\n      resolve(result);\n    };\n    img.src = info.path;\n  });\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * @hidden\n */\nexport interface CheckpointVariable {\n  filename: string;\n  shape: number[];\n}\n\n/**\n * @hidden\n */\nexport type CheckpointManifest = {\n  [varName: string]: CheckpointVariable\n};\n\nconst MANIFEST_FILE = 'manifest.json';\n\nexport class CheckpointLoader {\n  private checkpointManifest: CheckpointManifest;\n  private variables: {[varName: string]: NDArray};\n\n  constructor(private urlPath: string) {\n    if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') {\n      this.urlPath += '/';\n    }\n  }\n\n  private loadManifest(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n      xhr.open('GET', this.urlPath + MANIFEST_FILE);\n\n      xhr.onload = () => {\n        this.checkpointManifest = JSON.parse(xhr.responseText);\n        resolve();\n      };\n      xhr.onerror = (error) => {\n        throw new Error(\n            `${MANIFEST_FILE} not found at ${this.urlPath}. ` + error);\n      };\n      xhr.send();\n    });\n  }\n\n  getCheckpointManifest(): Promise<CheckpointManifest> {\n    if (this.checkpointManifest == null) {\n      return new Promise<CheckpointManifest>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          resolve(this.checkpointManifest);\n        });\n      });\n    }\n    return new Promise<CheckpointManifest>((resolve, reject) => {\n      resolve(this.checkpointManifest);\n    });\n  }\n\n  getAllVariables(): Promise<{[varName: string]: NDArray}> {\n    if (this.variables != null) {\n      return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n        resolve(this.variables);\n      });\n    }\n\n    return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n      this.getCheckpointManifest().then(\n          (checkpointDefinition: CheckpointManifest) => {\n            const variableNames = Object.keys(this.checkpointManifest);\n\n            const variablePromises: Array<Promise<NDArray>> = [];\n            for (let i = 0; i < variableNames.length; i++) {\n              variablePromises.push(this.getVariable(variableNames[i]));\n            }\n\n            Promise.all(variablePromises).then(variables => {\n              this.variables = {};\n              for (let i = 0; i < variables.length; i++) {\n                this.variables[variableNames[i]] = variables[i];\n              }\n              resolve(this.variables);\n            });\n          });\n    });\n  }\n\n  getVariable(varName: string): Promise<NDArray> {\n    if (!(varName in this.checkpointManifest)) {\n      throw new Error('Cannot load non-existant variable ' + varName);\n    }\n\n    const variableRequestPromiseMethod =\n        (resolve: (ndarray: NDArray) => void, reject: () => void) => {\n          const xhr = new XMLHttpRequest();\n          xhr.responseType = 'arraybuffer';\n          const fname = this.checkpointManifest[varName].filename;\n          xhr.open('GET', this.urlPath + fname);\n\n          xhr.onload = () => {\n            const values = new Float32Array(xhr.response);\n            const ndarray =\n                NDArray.make(this.checkpointManifest[varName].shape, {values});\n            resolve(ndarray);\n          };\n          xhr.onerror = (error) => {\n            throw new Error(\n                'Could not fetch variable ' + varName + ': ' + error);\n          };\n          xhr.send();\n        };\n\n    if (this.checkpointManifest == null) {\n      return new Promise<NDArray>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          new Promise<NDArray>(variableRequestPromiseMethod).then(resolve);\n        });\n      });\n    }\n    return new Promise<NDArray>(variableRequestPromiseMethod);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\nconst STATS_SAMPLE_PERCENTAGE = 0.1;\n\nexport interface DataStats {\n  exampleCount: number;\n  inputMin: number;\n  inputMax: number;\n  shape: number[];\n}\n\ninterface NormalizationInfo {\n  isNormalized: boolean;\n  // Bounds of the normalization if normalized.\n  lowerBound?: number;\n  upperBound?: number;\n  // Minimum and maximum values for each dimension of the original data. These\n  // are the same size as an input example. These are computed lazily, only if\n  // normalization is requested. If the data is un-normalized, these are kept\n  // around so they don't have to be recomputed.\n  minValues: Float32Array;\n  maxValues: Float32Array;\n}\n\nexport abstract class InMemoryDataset {\n  protected dataset: NDArray[][]|null;\n\n  // Contains information necessary for reconstruction of the original data\n  // after normalization.\n  private normalizationInfo: {[dataIndex: number]: NormalizationInfo};\n\n  constructor(protected dataShapes: number[][]) {\n    this.normalizationInfo = {};\n  }\n\n  getDataShape(dataIndex: number): number[] {\n    return this.dataShapes[dataIndex];\n  }\n\n  abstract fetchData(): Promise<void>;\n\n  getData(): NDArray[][]|null {\n    return this.dataset;\n  }\n\n  getStats(): DataStats[] {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    return this.dataset.map(d => this.getStatsForData(d));\n  }\n\n  // Computes stats across a sampled portion of the data.\n  private getStatsForData(data: NDArray[]): DataStats {\n    let inputMin = Number.POSITIVE_INFINITY;\n    let inputMax = Number.NEGATIVE_INFINITY;\n\n    let exampleIndices = data.map((example, i) => i);\n    util.shuffle(exampleIndices);\n    exampleIndices =\n        exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE);\n\n    for (let i = 0; i < exampleIndices.length; i++) {\n      const inputValues = data[exampleIndices[i]].getValues();\n      for (let j = 0; j < inputValues.length; j++) {\n        inputMin = Math.min(inputMin, inputValues[j]);\n        inputMax = Math.max(inputMax, inputValues[j]);\n      }\n    }\n\n    return {\n      inputMin,\n      inputMax,\n      exampleCount: data.length,\n      shape: data[0].shape,\n    };\n  }\n\n  /**\n   * @param examples NDArrays to be normalized.\n   * @param curLowerBounds An array containing the minimum value for each\n   * dimension or a fixed minimum value.\n   * @param curUpperBounds An array containing the maximum value for each\n   * dimension or a fixed maximum value.\n   * @param newLowerBounds An array containing new minimum values for each\n   * dimension, or a fixed minumum value to normalize the data to.\n   * @param newUpperBounds An array containing new maximum values for each\n   * dimension, or a fixed maximum value to normalize the data to.\n   */\n  private normalizeExamplesToRange(\n      examples: NDArray[], curLowerBounds: Float32Array|number,\n      curUpperBounds: Float32Array|number, newLowerBounds: Float32Array|number,\n      newUpperBounds: Float32Array|number): NDArray[] {\n    const curBoundsIsPerDimension =\n        (curUpperBounds instanceof Float32Array &&\n         curLowerBounds instanceof Float32Array);\n    const newBoundsIsPerDimension =\n        (newLowerBounds instanceof Float32Array &&\n         newUpperBounds instanceof Float32Array);\n\n    const inputSize = util.sizeFromShape(examples[0].shape);\n    const newExamples: NDArray[] = [];\n\n    examples.forEach(example => {\n      const inputValues = example.getValues();\n      const normalizedValues = new Float32Array(inputSize);\n      for (let j = 0; j < inputSize; j++) {\n        const curLowerBound = curBoundsIsPerDimension ?\n            (curLowerBounds as Float32Array)[j] :\n            curLowerBounds as number;\n        const curUpperBound = curBoundsIsPerDimension ?\n            (curUpperBounds as Float32Array)[j] :\n            curUpperBounds as number;\n        const curRange = curUpperBound - curLowerBound;\n\n        const newLowerBound = newBoundsIsPerDimension ?\n            (newLowerBounds as Float32Array)[j] :\n            newLowerBounds as number;\n        const newUpperBound = newBoundsIsPerDimension ?\n            (newUpperBounds as Float32Array)[j] :\n            newUpperBounds as number;\n        const newRange = newUpperBound - newLowerBound;\n\n        if (curRange === 0) {\n          normalizedValues[j] = newLowerBound;\n        } else {\n          normalizedValues[j] = newLowerBound +\n              newRange * (inputValues[j] - curLowerBound) / curRange;\n        }\n      }\n      newExamples.push(NDArray.make(example.shape, {values: normalizedValues}));\n    });\n    return newExamples;\n  }\n\n  private computeBounds(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    const size = util.sizeFromShape(this.dataset[dataIndex][0].shape);\n\n    // Compute min and max values for every dimension.\n    this.normalizationInfo[dataIndex] = {\n      isNormalized: false,\n      minValues: new Float32Array(size),\n      maxValues: new Float32Array(size)\n    };\n\n    for (let i = 0; i < size; i++) {\n      this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY;\n      this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY;\n    }\n\n    this.dataset[dataIndex].forEach(example => {\n      const inputValues = example.getValues();\n      for (let k = 0; k < size; k++) {\n        this.normalizationInfo[dataIndex].minValues[k] = Math.min(\n            this.normalizationInfo[dataIndex].minValues[k], inputValues[k]);\n        this.normalizationInfo[dataIndex].maxValues[k] = Math.max(\n            this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]);\n      }\n    });\n  }\n\n  normalizeWithinBounds(\n      dataIndex: number, lowerBound: number, upperBound: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n    if (dataIndex >= this.dataset.length) {\n      throw new Error('dataIndex out of bounds.');\n    }\n\n    if (this.normalizationInfo[dataIndex] == null) {\n      this.computeBounds(dataIndex);\n    }\n\n    // curLower/UpperBounds of the current data set can either be fixed numbers\n    // if the data has already been normalized, or curLower/Upper for each\n    // dimension if it hasn't been normalized yet.\n    let curLowerBounds: Float32Array|number;\n    let curUpperBounds: Float32Array|number;\n\n    if (this.normalizationInfo[dataIndex].isNormalized) {\n      curLowerBounds = this.normalizationInfo[dataIndex].lowerBound!;\n      curUpperBounds = this.normalizationInfo[dataIndex].upperBound!;\n    } else {\n      curLowerBounds = this.normalizationInfo[dataIndex].minValues;\n      curUpperBounds = this.normalizationInfo[dataIndex].maxValues;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound,\n        upperBound);\n    this.normalizationInfo[dataIndex].isNormalized = true;\n    this.normalizationInfo[dataIndex].lowerBound = lowerBound;\n    this.normalizationInfo[dataIndex].upperBound = upperBound;\n  }\n\n  private isNormalized(dataIndex: number): boolean {\n    return this.normalizationInfo != null &&\n        this.normalizationInfo[dataIndex].isNormalized;\n  }\n\n  removeNormalization(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Training or test data is null.');\n    }\n\n    if (!this.isNormalized(dataIndex)) {\n      return;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n    this.normalizationInfo[dataIndex].isNormalized = false;\n  }\n\n  unnormalizeExamples(examples: NDArray[], dataIndex: number): NDArray[] {\n    if (!this.isNormalized(dataIndex)) {\n      return examples;\n    }\n\n    return this.normalizeExamplesToRange(\n        examples, this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n  }\n\n  dispose() {\n    if (this.dataset == null) {\n      return;\n    }\n\n    for (let i = 0; i < this.dataset.length; i++) {\n      for (let j = 0; j < this.dataset[i].length; j++) {\n        this.dataset[i][j].dispose();\n      }\n    }\n    this.dataset = [];\n  }\n}\n\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GraphLayers} from './graph_layers';\nimport * as concat3d_util from './math/concat3d_util';\nimport * as conv_util from './math/conv_util';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * Graph is the primary container structure for learn.js operations. Graph\n * holds the topology of operation nodes and the connectivity between them.\n */\nexport class Graph {\n  layers: GraphLayers;\n\n  constructor() {\n    this.layers = new GraphLayers(this);\n  }\n\n  /**\n   * Creates a named variable. Variables are tensors that maintain state across\n   * session calls and whose values are adjusted during backpropagation\n   * training.\n   * @param name The name of this variable.\n   * @param data The NDArray to associate with this variable tensor.\n   * @return The tensor representing the variable.\n   */\n  variable(name: string, data: NDArray): Tensor {\n    return this.addNodeAndReturnOutput(new VariableNode(this, name, data));\n  }\n\n  /**\n   * Inserts a placeholder for a tensor that will be always fed. Placeholders\n   * are input tensors whose values are provided by the client via feed\n   * dictionaries. Placeholders are not updated as part of training; they are\n   * only used as immutable input.\n   * @param name The name of this placeholder.\n   * @param shape The shape of the placeholder tensor.\n   * @return The tensor representing the placeholder.\n   */\n  placeholder(name: string, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape));\n  }\n\n  /**\n   * Constant value that persists across session calls.\n   * @param value The value to return.\n   * @return A node outputing the constant value.\n   */\n  constant(value: ArrayData): Tensor {\n    let finalValue: NDArray;\n    if (typeof value === 'number') {\n      finalValue = Scalar.new(value);\n    } else if (value instanceof NDArray) {\n      finalValue = value;\n    } else if (value instanceof Array) {\n      const vals = new Float32Array(util.flatten(value));\n      finalValue = NDArray.make(util.inferShape(value), {values: vals});\n    } else {\n      throw new Error('unimplemented constant type.');\n    }\n    return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue));\n  }\n\n  /**\n   * Reshape the input tensor.\n   * @param x The input tensor to be reshaped.\n   * @param shape The shape of the output tensor.\n   * @return The tensor representing the reshape operation.\n   */\n  reshape(x: Tensor, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(\n        new ReshapeNode(this, 'Reshape', x, shape));\n  }\n\n  /**\n   * Computes a fused linear combination of two tensors.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor. Same shape as t1.\n   * @param c1 Coefficient of t1. Must be size 1.\n   * @param c2 Coefficient of t2. Must be size 1.\n   * @return The tensor representing c1*t1+c2*t2.\n   */\n  fusedLinearCombination(x1: Tensor, x2: Tensor, c1: Tensor, c2: Tensor):\n      Tensor {\n    return this.addNodeAndReturnOutput(\n        new FusedLinearCombinationNode(this, x1, x2, c1, c2));\n  }\n\n\n  /**\n   * Adds two tensors (elementwise). Broadcasts if one of the tensors is scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1+t2.\n   */\n  add(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new AddNode(this, x1, x2));\n  }\n\n  /**\n   * Subtracts two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1-t2.\n   */\n  subtract(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2));\n  }\n\n  /**\n   * Multiply two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1*t2.\n   */\n  multiply(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2));\n  }\n\n  /**\n   * Divide two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1 / t2.\n   */\n  divide(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2));\n  }\n\n  /**\n   * Computes the sum of elements in the tensor.\n   * @param x The input tensor.\n   */\n  reduceSum(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReduceSumNode(this, x));\n  }\n\n  /**\n   * Concats two 3D tensors along a given axis.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing concat of two tensors along axis.\n   */\n  concat3d(x1: Tensor, x2: Tensor, axis: number): Tensor {\n    return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis));\n  }\n\n  /**\n   * Computes the dot product between two matrices.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing the dot product of x1 and x2.\n   */\n  matmul(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2));\n  }\n\n  /**\n   * Computes a 2D convolution.\n   * @param x The input tensor to the convolution operation.\n   * @param w The weight tensor used by the convolution operation.\n   * @param b The bias tensor used by the convolution operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param outputDepth The output depth of the convolution operation.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the convolution operation.\n   */\n  conv2d(\n      x: Tensor, w: Tensor, b: Tensor, fieldSize: number, outputDepth: number,\n      stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(new Convolution2DNode(\n        this, x, w, b, fieldSize, outputDepth, stride, zeroPad));\n  }\n\n  /**\n   * Computes a 2D max pool of x.\n   * @param x The input tensor to the max pool operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the max pool operation.\n   */\n  maxPool(x: Tensor, fieldSize: number, stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(\n        new MaxPoolNode(this, x, fieldSize, stride, zeroPad));\n  }\n\n  /**\n   * Computes exponential of x element-wise.\n   * @param x The input tensor to the exp.\n   * @return The tensor representing the e ^ x operation.\n   */\n  exp(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ExpNode(this, x));\n  }\n\n  /**\n   * Computes log of x element-wise.\n   * @param x The input tensor to the log.\n   * @return The tensor representing the ln(x) operation.\n   */\n  log(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new LogNode(this, x));\n  }\n\n  /**\n   * Computes ReLU of x element-wise.\n   * @param x The input tensor to the ReLU.\n   * @return The tensor representing the ReLU operation.\n   */\n  relu(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReLUNode(this, x));\n  }\n\n  /**\n   * Computes TanH of x element-wise.\n   * @param x The input tensor to the TanH.\n   * @return The tensor representing the TanH operation.\n   */\n  tanh(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new TanHNode(this, x));\n  }\n\n  /**\n   * Computes Sigmoid of x element-wise.\n   * @param x The input tensor to the sigmoid.\n   * @return The tensor representing the sigmoid operation.\n   */\n  sigmoid(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SigmoidNode(this, x));\n  }\n\n  /**\n   * Computes square of x element-wise.\n   * @param x The input tensor to the square.\n   */\n  square(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SquareNode(this, x));\n  }\n\n  /**\n   * Computes softmax probabilities from logits.\n   *\n   * @param x The input logits.\n   * @return The softmax probabilities.\n   */\n  softmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SoftmaxNode(this, x));\n  }\n\n  /**\n   * Creates a softmax cross-entropy cost operation in the graph.\n   * @param x The input tensor to classify.\n   * @return The tensor representing the softmax cross-entropy cost operation.\n   */\n  softmaxCrossEntropyCost(x: Tensor, target: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(\n        new SoftmaxCrossEntropyCostNode(this, x, target));\n  }\n\n  /**\n   * Creates a mean-squared cost operation in the graph.\n   * @param label The label tensor.\n   * @param prediction The prediction tensor.\n   * @return The tensor representing the mean-squared cost operation.\n   */\n  meanSquaredCost(label: Tensor, prediction: Tensor) {\n    return this.addNodeAndReturnOutput(\n        new MeanSquaredCostNode(this, label, prediction));\n  }\n\n  /**\n   * Returns the flattened index of the maximum entry in the tensor.\n   * @param x The tensor with the value.\n   * @return A Scalar tensor with the index of the maximum entry.\n   */\n  argmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxNode(this, x));\n  }\n\n  /**\n   * Creates an argmax equals operation in the graph.\n   * @param x1 First input tensor to check against.\n   * @param x2 Second input tensor to check against.\n   * @return The tensor representing the argmax equals operation.\n   */\n  argmaxEquals(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2));\n  }\n\n  private addNodeAndReturnOutput(node: Node): Tensor {\n    this.nodes.push(node);\n    node.validate();\n    return node.output;\n  }\n\n  getNodes(): Node[] {\n    return this.nodes;\n  }\n\n  private nodes: Node[] = [];\n}\n\n/**\n * Tensor represents the output of an operation node in the graph.\n * Tensors have no data associated with them, but maintain a shape array\n * to determine operation compatibility. All graph methods that create graph\n * operations return Tensor objects, which can be thought of as 'handles' to\n * operations.\n */\nexport class Tensor {\n  node: Node;\n  id: number;\n  /**\n   * @param shape The shape of this tensor, in dimension sizes.\n   */\n  constructor(public shape: number[]) {\n    this.id = Tensor.nextID++;\n  }\n  private static nextID = 0;\n}\n\n/**\n * Node is the concrete base class for all operations in the graph.\n * Users generally don't need to interact directly with Node instances, but they\n * are provided for informational and introspection purposes.\n *\n * @hidden\n */\nexport abstract class Node {\n  /**\n   * @param graph The graph containing this node\n   * @param name The name of this node\n   * @param inputs A dictionary of named Tensors that comprise this node's\n   * inputs.\n   * @param output This node's output Tensor\n   */\n  constructor(\n      public graph: Graph, public name: string,\n      public inputs: {[name: string]: Tensor}, public output: Tensor) {\n    this.id = Node.nextID++;\n    output.node = this;\n  }\n  abstract validate(): void;\n  id: number;\n  private static nextID = 0;\n}\n\n/**\n * VariableNode represents a variable, a user-provided NDArray that's\n * adjusted during backpropagation training.\n *\n * @hidden\n */\nexport class VariableNode extends Node {\n  constructor(graph: Graph, name: string, public data: NDArray) {\n    super(graph, name, {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding variable op: Data for variable \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * PlaceholderNode represents a placeholder, a user-provided NDArray\n * that's used as immutable input during inference and training.\n *\n * @hidden\n */\nexport class PlaceholderNode extends Node {\n  constructor(graph: Graph, name: string, shape: number[]) {\n    super(graph, name, {}, new Tensor(shape));\n  }\n  validate() {}\n}\n\n/**\n * ConstantNode represents a constant value in the graph.\n *\n * @hidden\n */\nexport class ConstantNode extends Node {\n  constructor(graph: Graph, public data: NDArray) {\n    super(graph, 'Constant', {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding constant: data for placeholder \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * ReshapeNode represents a reshape operation in the graph.\n *\n * @hidden\n */\nexport class ReshapeNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, public name: string, private x: Tensor,\n      private shape: number[]) {\n    super(graph, name, {x}, new Tensor(shape));\n  }\n  validate() {\n    const xSize = util.sizeFromShape(this.x.shape);\n    const shapeSize = util.sizeFromShape(this.shape);\n    util.assert(\n        xSize === shapeSize,\n        'Error making reshape operation: input Tensor to reshape \\'' +\n            this.name + '\\' of shape (' + this.x.shape +\n            ') does not match size of requested shape ' + this.shape + '.');\n  }\n}\n\n/**\n * LinearCombinationNode represents a linear combination of two tensors.\n * @hidden\n */\nexport class FusedLinearCombinationNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n  static readonly C1 = 'c1';\n  static readonly C2 = 'c2';\n  constructor(\n      graph: Graph, private t1: Tensor, private t2: Tensor, private c1: Tensor,\n      private c2: Tensor) {\n    super(graph, 'Linear Combination', {t1, t2, c1, c2}, new Tensor(t1.shape));\n  }\n\n  validate() {\n    util.assertShapesMatch(this.t1.shape, this.t2.shape);\n    if (!util.isScalarShape(this.c1.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c1 is not a scalar, got ' +\n          'shape: ' + this.c1.shape);\n    }\n    if (!util.isScalarShape(this.c2.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c2 is not a scalar, got ' +\n          'shape: ' + this.c2.shape);\n    }\n  }\n}\n\n/**\n * @hidden\n */\nexport class AddNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Add', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding add operation op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SubtractNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Subtract', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding subtract op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class MultiplyNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Multiply', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding multiply op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class DivideNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Divide', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding divide op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReduceSumNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReduceSum', {x}, new Tensor([]));\n  }\n\n  validate() {}\n}\n\n/**\n * Concat3DNode represents a 3D concatenation of two tensors along an axis.\n * @hidden\n */\nexport class Concat3DNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  static readonly AXIS = 'axis';\n  constructor(\n      graph: Graph, private x1: Tensor, private x2: Tensor,\n      public axis: number) {\n    super(\n        graph, 'Concat3D', {x1, x2},\n        new Tensor(concat3d_util.computeConcat3DOutputShape(\n            x1.shape, x2.shape, axis)));\n  }\n  validate() {\n    concat3d_util.assertConcat3DShapesMatch(\n        this.x1.shape, this.x2.shape, this.axis);\n  }\n}\n\nfunction getMatMulOutputShape(x1Shape: number[], x2Shape: number[]): number[] {\n  if (x1Shape.length === 1 && x2Shape.length === 1) {\n    return [1];\n  } else if (x1Shape.length === 1 && x2Shape.length === 2) {\n    return [x2Shape[1]];\n  } else if (x1Shape.length === 2 && x2Shape.length === 1) {\n    return [x1Shape[0]];\n  }\n  return [x1Shape[0], x2Shape[1]];\n}\n\n/**\n * MatMulNode represents a fully connected layer in the graph.\n * @hidden\n */\nexport class MatMulNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(\n        graph, 'MatMul', {x1, x2},\n        new Tensor(getMatMulOutputShape(x1.shape, x2.shape)));\n  }\n\n  validate() {\n    if (this.x1.shape.length === 2 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: inner shapes of matrices with shapes ' +\n              this.x1.shape + ' and ' + this.x2.shape + ' must match.');\n    } else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: second dimension of matrix with shape ' +\n              this.x1.shape + ' must match size of vector with shape ' +\n              this.x2.shape + '.');\n    } else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[0] === this.x2.shape[0],\n          'Error adding matmul op: size of vector with shape ' + this.x1.shape +\n              ' must match first dimension of matrix with ' +\n              'shape ' + this.x2.shape + '.');\n    } else {\n      throw new Error(\n          'Error adding matmul op: inputs must be vectors or matrices.');\n    }\n  }\n}\n\n/**\n * Convolution2DNode represents a 2d convolution operation in the graph.\n * @hidden\n */\nexport class Convolution2DNode extends Node {\n  static readonly X = 'x';\n  static readonly W = 'w';\n  static readonly B = 'b';\n  constructor(\n      graph: Graph, private x: Tensor, private w: Tensor, private b: Tensor,\n      public fieldSize: number, public outputDepth: number, public stride = 1,\n      public zeroPad?: number) {\n    super(\n        graph, 'Convolution 2D', {x, w, b},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, outputDepth, stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding conv2d op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n    util.assert(\n        this.w.shape.length === 4,\n        'Error adding conv2d op: weights must be of rank 4, but got shape: ' +\n            this.w.shape + '.');\n    util.assert(\n        this.b.shape.length === 1,\n        'Error adding conv2d op: biases must be of rank 1, but got shape: ' +\n            this.b.shape + '.');\n\n    util.assert(\n        this.x.shape[2] === this.w.shape[2],\n        'Error adding conv2d op: depth of input (' + this.x.shape[2] +\n            ') must match input depth for weights (' + this.w.shape[2] + ').');\n  }\n}\n\n/**\n * MaxPoolNode represents a 2d max pool operation in the graph.\n * @hidden\n */\nexport class MaxPoolNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, private x: Tensor, public fieldSize: number,\n      public stride = 1, public zeroPad?: number) {\n    super(\n        graph, 'Max pool', {x},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, x.shape[2], stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding maxPool op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n  }\n}\n\n/**\n * ReLUNode represents a ReLU operation in the graph.\n * @hidden\n */\nexport class ReLUNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReLU', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * ExpNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class ExpNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Exp', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * LogNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class LogNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Log', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * TanHNode represents a tanh operation in the graph.\n * @hidden\n */\nexport class TanHNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'TanH', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SigmoidNode represents a sigmoid operation in the graph.\n * @hidden\n */\nexport class SigmoidNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Sigmoid', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * Square node represents an element-wise square operation in the graph.\n * @hidden\n */\nexport class SquareNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Square', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SoftmaxCrossEntropyCostNode represents a softmax cross-entropy cost operation\n * in the graph.\n * @hidden\n */\nexport class SoftmaxCrossEntropyCostNode extends Node {\n  static readonly X = 'x';\n  static readonly TARGET = 'target';\n  constructor(graph: Graph, private x: Tensor, private target: Tensor) {\n    super(graph, 'SoftmaxCrossEntropyCost', {x, target}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x.shape, this.target.shape),\n        'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape +\n            ') must match target shape (' + this.target.shape + ').');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SoftmaxNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, private x: Tensor) {\n    super(graph, 'Softmax', {x}, new Tensor(x.shape));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 1,\n        'The input to a softmax must be a 1-D tensor');\n    util.assert(\n        this.x.shape[0] >= 2,\n        'The input to a softmax must have at least 2 values');\n  }\n}\n\n/**\n * MeanSquaredCostNode represents a mean squared cost operation\n * in the graph.\n *\n * @hidden\n */\nexport class MeanSquaredCostNode extends Node {\n  static readonly LABEL = 'label';\n  static readonly PREDICTION = 'prediction';\n  constructor(graph: Graph, private label: Tensor, private prediction: Tensor) {\n    super(graph, 'Mean Squared Cost', {label, prediction}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.label.shape, this.prediction.shape),\n        'Error adding meanSquaredCost op: label shape (' + this.label.shape +\n            ') must match prediction shape (' + this.prediction.shape + ').');\n  }\n}\n\n/**\n * ArgMaxNode represents an argmax operation in the graph.\n * @hidden\n */\nexport class ArgMaxNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, public x: Tensor) {\n    super(graph, 'ArgMax', {x}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.x.shape) > 0,\n        'Error adding argmax op: input tensor must have at least one entry.');\n  }\n}\n\n/**\n * ArgMaxEqualsNode represents a argmax equals operation in the graph.\n * @hidden\n */\nexport class ArgMaxEqualsNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(graph, 'ArgMaxEquals', {x1, x2}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x1.shape, this.x2.shape),\n        'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape +\n            ') must match x2 shape (' + this.x2.shape + ').');\n  }\n}\n\n/**\n * Split nodes are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n * @hidden\n */\nexport class SplitNode extends Node {\n  static readonly X = 'x';\n\n  outputs: Tensor[] = [];\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'SplitNode', {x}, new Tensor(x.shape));\n  }\n\n  /**\n   * Registers a new consumer of this split node, i.e. a new node that uses the\n   * node's output tensor.\n   */\n  getNewOutputTensor(): Tensor {\n    const output = new Tensor(this.inputs[SplitNode.X].shape);\n    output.node = this;\n    this.outputs.push(output);\n    return output;\n  }\n  validate() {}\n}\n\n/**\n * @hidden\n */\nexport type ArrayData =\n    NDArray|number|number[]|number[][]|number[][][]|number[][][][];\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Tensor} from './graph';\nimport {Initializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nimport {NDArray} from './math/ndarray';\n\n/**\n * A layers sugar class around the graph that initializes variables\n * automatically for layers.\n */\nexport class GraphLayers {\n  constructor(private g: Graph) {}\n\n  dense(\n      name: string, x: Tensor, units: number,\n      activation: ((x: Tensor) => Tensor)|null = null, useBias = true,\n      kernelInitializer: Initializer = new VarianceScalingInitializer(),\n      biasInitializer: Initializer = new ZerosInitializer()) {\n    const weights = this.g.variable(\n        name + '-weights',\n        kernelInitializer.initialize([x.shape[0], units], x.shape[0], units));\n\n    let out = this.g.matmul(x, weights);\n\n    if (useBias) {\n      const bias = this.g.variable(\n          name + '-bias',\n          biasInitializer.initialize([units], x.shape[0], units));\n      out = this.g.add(out, bias);\n    }\n\n    if (activation != null) {\n      out = activation(out);\n    }\n\n    return out;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as dataset from './dataset';\nimport {Graph, Tensor} from './graph';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArrayMathCPU} from './math/math_cpu';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {CostReduction, FeedEntry, Session} from './session';\n\nconst DEFAULT_EVAL_INTERVAL_MS = 1500;\nconst DEFAULT_COST_INTERVAL_MS = 500;\nconst DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000;\n\nexport interface GraphRunnerEventObserver {\n  batchesTrainedCallback?: (totalBatchesTrained: number) => void;\n  avgCostCallback?: (avgCost: Scalar) => void;\n  metricCallback?: (metric: NDArray) => void;\n  inferenceExamplesCallback?:\n      (feeds: FeedEntry[][], inferenceValues: NDArray[]) => void;\n  inferenceExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  trainExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  totalTimeCallback?: (totalTimeSec: number) => void;\n  doneTrainingCallback?: () => void;\n}\n\nexport enum MetricReduction {\n  SUM,\n  MEAN\n}\n\n/**\n * A class that drives the training of a graph model given a dataset. It allows\n * the user to provide a set of callbacks for measurements like cost, accuracy,\n * and speed of training.\n */\nexport class GraphRunner {\n  private costTensor: Tensor;\n  private trainFeedEntries: FeedEntry[];\n  private batchSize: number;\n  private optimizer: Optimizer;\n  private currentTrainLoopNumBatches: number|undefined;\n  private costIntervalMs: number;\n\n  private metricTensor: Tensor|undefined;\n  private metricFeedEntries: FeedEntry[]|undefined;\n  private metricBatchSize: number|undefined;\n  private metricReduction: MetricReduction;\n  private metricIntervalMs: number;\n\n  private inferenceTensor: Tensor;\n  private inferenceFeedEntries: FeedEntry[]|undefined;\n  private inferenceExampleIntervalMs: number;\n  private inferenceExampleCount: number;\n\n  // Runtime information.\n  private isTraining: boolean;\n  private totalBatchesTrained: number;\n  private batchesTrainedThisRun: number;\n  private lastComputedMetric: NDArray;\n\n  private isInferring: boolean;\n  private currentInferenceLoopNumPasses: number|undefined;\n  private inferencePassesThisRun: number;\n\n  private trainStartTimestamp: number;\n  private lastCostTimestamp = 0;\n  private lastEvalTimestamp = 0;\n\n  private lastStopTimestamp: number|null;\n  private totalIdleTimeMs = 0;\n\n  private zeroScalar: Scalar;\n  private metricBatchSizeScalar: Scalar;\n\n  constructor(\n      private math: NDArrayMath, private session: Session,\n      private eventObserver: GraphRunnerEventObserver) {\n    this.resetStatistics();\n    this.zeroScalar = Scalar.new(0);\n  }\n\n  resetStatistics() {\n    this.totalBatchesTrained = 0;\n    this.totalIdleTimeMs = 0;\n    this.lastStopTimestamp = null;\n  }\n\n  /**\n   * Start the training loop with an optional number of batches to train for.\n   * Optionally takes a metric tensor and feed entries to compute periodically.\n   * This can be used for computing accuracy, or a similar metric.\n   */\n  train(\n      costTensor: Tensor, trainFeedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, numBatches?: number, metricTensor?: Tensor,\n      metricFeedEntries?: FeedEntry[], metricBatchSize?: number,\n      metricReduction = MetricReduction.MEAN,\n      evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS,\n      costIntervalMs = DEFAULT_COST_INTERVAL_MS) {\n    this.costTensor = costTensor;\n    this.trainFeedEntries = trainFeedEntries;\n    this.metricTensor = metricTensor;\n    this.metricFeedEntries = metricFeedEntries;\n    if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) {\n      if (this.metricBatchSizeScalar != null) {\n        this.metricBatchSizeScalar.dispose();\n      }\n      this.metricBatchSizeScalar = Scalar.new(metricBatchSize);\n    }\n    this.metricBatchSize = metricBatchSize;\n    this.metricReduction = metricReduction;\n    this.batchSize = batchSize;\n    this.optimizer = optimizer;\n\n    this.metricIntervalMs = evalIntervalMs;\n    this.costIntervalMs = costIntervalMs;\n    this.currentTrainLoopNumBatches = numBatches;\n\n    this.batchesTrainedThisRun = 0;\n    this.isTraining = true;\n    this.trainStartTimestamp = performance.now();\n    this.trainNetwork();\n  }\n\n  stopTraining() {\n    this.isTraining = false;\n    this.lastStopTimestamp = performance.now();\n  }\n\n  resumeTraining() {\n    this.isTraining = true;\n    if (this.lastStopTimestamp != null) {\n      this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp;\n    }\n    this.trainNetwork();\n  }\n\n  private trainNetwork() {\n    if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) {\n      this.stopTraining();\n    }\n\n    if (!this.isTraining) {\n      if (this.eventObserver.doneTrainingCallback != null) {\n        this.eventObserver.doneTrainingCallback();\n      }\n      return;\n    }\n\n    const start = performance.now();\n    const shouldComputeCost = this.eventObserver.avgCostCallback != null &&\n        (start - this.lastCostTimestamp > this.costIntervalMs);\n    if (shouldComputeCost) {\n      this.lastCostTimestamp = start;\n    }\n\n    const costReduction =\n        shouldComputeCost ? CostReduction.MEAN : CostReduction.NONE;\n\n    this.math.scope((keep) => {\n      const avgCost = this.session.train(\n          this.costTensor, this.trainFeedEntries, this.batchSize,\n          this.optimizer, costReduction);\n\n      if (shouldComputeCost) {\n        const trainTime = performance.now() - start;\n\n        this.eventObserver.avgCostCallback!(avgCost);\n\n        if (this.eventObserver.trainExamplesPerSecCallback != null) {\n          const examplesPerSec = (this.batchSize * 1000 / trainTime);\n          this.eventObserver.trainExamplesPerSecCallback(examplesPerSec);\n        }\n      }\n\n      if (this.eventObserver.metricCallback != null &&\n          this.metricFeedEntries != null &&\n          start - this.lastEvalTimestamp > this.metricIntervalMs) {\n        this.lastEvalTimestamp = start;\n\n        if (this.lastComputedMetric != null) {\n          this.lastComputedMetric.dispose();\n        }\n        this.lastComputedMetric = this.computeMetric();\n        this.eventObserver.metricCallback(this.lastComputedMetric);\n      }\n\n      if (this.eventObserver.totalTimeCallback != null) {\n        this.eventObserver.totalTimeCallback(\n            (start - this.trainStartTimestamp) / 1000);\n      }\n\n      this.batchesTrainedThisRun++;\n      this.totalBatchesTrained++;\n\n      if (this.eventObserver.batchesTrainedCallback != null) {\n        this.eventObserver.batchesTrainedCallback(this.totalBatchesTrained);\n      }\n\n    });\n    setTimeout(() => this.trainNetwork());\n  }\n\n  infer(\n      inferenceTensor: Tensor, inferenceFeedEntries: FeedEntry[],\n      inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS,\n      inferenceExampleCount = 5, numPasses?: number) {\n    if (this.eventObserver.inferenceExamplesCallback == null &&\n        this.eventObserver.inferenceExamplesPerSecCallback == null) {\n      throw new Error(\n          'Cannot start inference loop, no inference example or ' +\n          'examples/sec observer provided.');\n    }\n\n    // Make sure the feed values are providers, and not NDArrays.\n    for (let i = 0; i < inferenceFeedEntries.length; i++) {\n      const feedEntry = inferenceFeedEntries[i];\n\n      if (feedEntry.data instanceof NDArray) {\n        throw new Error(\n            'Cannot start inference on the model runner with feed entries of ' +\n            'type NDArray. Please use InputProviders.');\n      }\n    }\n\n    this.inferenceExampleIntervalMs = inferenceExampleIntervalMs;\n    this.inferenceTensor = inferenceTensor;\n    this.inferenceFeedEntries = inferenceFeedEntries;\n    this.inferenceExampleCount = inferenceExampleCount;\n    this.currentInferenceLoopNumPasses = numPasses;\n    if (!this.isInferring) {\n      this.inferencePassesThisRun = 0;\n      setTimeout(() => this.inferNetwork());\n    }\n    this.isInferring = true;\n  }\n\n  private inferNetwork() {\n    if (!this.isInferring ||\n        this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) {\n      return;\n    }\n\n    this.math.scope((keep, track) => {\n      const feeds: FeedEntry[][] = [];\n      const inferenceValues: NDArray[] = [];\n\n      const start = performance.now();\n      for (let i = 0; i < this.inferenceExampleCount; i++) {\n        // Populate a new FeedEntry[] populated with NDArrays.\n        const ndarrayFeedEntries: FeedEntry[] = [];\n        for (let j = 0; j < this.inferenceFeedEntries!.length; j++) {\n          const feedEntry = this.inferenceFeedEntries![j];\n          ndarrayFeedEntries.push({\n            tensor: feedEntry.tensor,\n            data:\n                track((feedEntry.data as InputProvider).getNextCopy(this.math))\n          });\n        }\n        feeds.push(ndarrayFeedEntries);\n\n        inferenceValues.push(\n            this.session.eval(this.inferenceTensor, ndarrayFeedEntries));\n      }\n\n      if (this.eventObserver.inferenceExamplesPerSecCallback != null) {\n        // Force a GPU download, since inference results are generally needed on\n        // the CPU and it's more fair to include blocking on the GPU to complete\n        // its work for the inference measurement.\n        inferenceValues[inferenceValues.length - 1].getValues();\n\n        const inferenceExamplesPerSecTime = performance.now() - start;\n\n        const examplesPerSec =\n            (this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime);\n        this.eventObserver.inferenceExamplesPerSecCallback!(examplesPerSec);\n      }\n\n      if (this.eventObserver.inferenceExamplesCallback != null) {\n        this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues);\n      }\n      this.inferencePassesThisRun++;\n\n    });\n    setTimeout(() => this.inferNetwork(), this.inferenceExampleIntervalMs);\n  }\n\n  stopInferring() {\n    this.isInferring = false;\n  }\n\n  isInferenceRunning(): boolean {\n    return this.isInferring;\n  }\n\n  computeMetric(): Scalar {\n    if (this.metricFeedEntries == null) {\n      throw new Error('Cannot compute metric, no metric FeedEntries provided.');\n    }\n\n    let metric = this.zeroScalar;\n\n    return this.math.scope((keep) => {\n      for (let i = 0; i < this.metricBatchSize!; i++) {\n        const metricValue =\n            this.session.eval(this.metricTensor!, this.metricFeedEntries!);\n\n        metric = this.math.add(metric, metricValue);\n      }\n\n      if (this.metricReduction === MetricReduction.MEAN) {\n        metric = this.math.divide(metric, this.metricBatchSizeScalar);\n      }\n\n      return metric;\n    });\n  }\n\n  getTotalBatchesTrained(): number {\n    return this.totalBatchesTrained;\n  }\n\n  getLastComputedMetric(): Scalar {\n    return this.lastComputedMetric;\n  }\n\n  setMath(math: NDArrayMath) {\n    this.math = math;\n  }\n\n  setSession(session: Session) {\n    this.session = session;\n  }\n\n  setInferenceTensor(inferenceTensor: Tensor) {\n    this.inferenceTensor = inferenceTensor;\n  }\n\n  setInferenceExampleCount(inferenceExampleCount: number) {\n    this.inferenceExampleCount = inferenceExampleCount;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Graph, Node, PlaceholderNode, Tensor, VariableNode} from './graph';\nimport * as priority_queue from './priority_queue';\nimport {PriorityQueue} from './priority_queue';\nimport {TensorArrayMap} from './tensor_array_map';\n\n/**\n * Given a target node in a graph, accumulate the set of all nodes that need to\n * be evaluated in order to evaluate the target graph. Traversal stops anywhere\n * a node's values are fed in externally via \"feed dicts\".\n * @param nodes The nodes to be evaluated.\n * @param terminatingNodes The set of nodes that stop traversal.\n * @return The unordered set of nodes that need to be evaluated.\n */\nexport function getUnorderedEvaluationSet(\n    nodes: Node[], terminatingNodes: Node[]): Node[] {\n  const terminatingNodeMap: {[id: number]: Node} = {};\n  const seen: {[id: number]: Node} = {};\n  const set: Node[] = [];\n  const visit: Node[] = nodes.slice();\n  terminatingNodes.forEach(node => terminatingNodeMap[node.id] = node);\n  /* Flood fill: While the 'to visit' stack is not empty, pop a node off of it.\n   * If the node has not yet been visited, add it to the set, mark it as seen,\n   * and enqueue all of its ancestor (input) nodes. */\n  while (visit.length !== 0) {\n    const cur = visit.pop()!;\n    if (seen[cur.id] == null) {\n      if (terminatingNodeMap[cur.id] == null) {\n        Object.keys(cur.inputs)\n            .map(inputName => cur.inputs[inputName])\n            .forEach(input => visit.push(input.node));\n      }\n      set.push(cur);\n      seen[cur.id] = cur;\n    }\n  }\n  return set;\n}\n\n/**\n * Given a set of nodes, compute their order such that all dependent nodes are\n * evaluated after their dependees. This is the 'inference order' for nodes in\n * the operation graph.\n * @param unorderedEvaluationSet The unordered set of nodes that need to be\n * evaluated.\n * @return The input nodes in forward evaluation order.\n */\nexport function getOrderedEvaluationSet(unorderedEvaluationSet: Node[]):\n    Node[] {\n  /* A priority queue is used, where the priority is the remaining number of\n   * unevaluated nodes whose inputs come from the element node. This guarantees\n   * that all downstream nodes will be dequeued before their ancestors. */\n  const set: Node[] = [];\n  const nodeIndices: {[id: number]: number} = {};\n  const pendingDependencies: {[id: number]: number} = {};\n\n  /* The queue priority callback looks at the number of pending dependencies of\n   * a given node. The queue index observer callback maintains the location of\n   * each node in the array, for priority updates. */\n  const nodeQueue = new PriorityQueue<Node>(\n      (a: Node, b: Node) => priority_queue.defaultCompare(\n          pendingDependencies[a.id], pendingDependencies[b.id]),\n      (node: Node, newIndex: number) => nodeIndices[node.id] = newIndex);\n\n  unorderedEvaluationSet.forEach(node => pendingDependencies[node.id] = 0);\n\n  /* For every descendent of a node (output of ancestor is input to descendant),\n   * increment the 'pending dependency count' for the ancestor. This prepares\n   * the 'pending dependency count' as a priority map. */\n  unorderedEvaluationSet.forEach(\n      node => Object.keys(node.inputs)\n                  .map(key => node.inputs[key])\n                  .forEach(input => {\n                    if (unorderedEvaluationSet.indexOf(input.node) !== -1) {\n                      pendingDependencies[input.node.id]++;\n                    }\n                  }));\n\n  unorderedEvaluationSet.forEach(node => nodeQueue.enqueue(node));\n\n  while (!nodeQueue.empty()) {\n    set.unshift(nodeQueue.dequeue());\n    /* As each node is visited, decrement the 'pending dependency count' of\n     * each ancestor, and tell the priority queue that the priority has changed.\n     */\n    Object.keys(set[0].inputs).map(key => set[0].inputs[key]).forEach(input => {\n      if (unorderedEvaluationSet.indexOf(input.node) === -1) {\n        return;\n      }\n      pendingDependencies[input.node.id]--;\n      nodeQueue.update(input.node, nodeIndices[input.node.id]);\n    });\n  }\n\n  return set;\n}\n\n/**\n * @return True iff the node is an input node.\n */\nexport function isInputNode(node: Node): boolean {\n  return Object.keys(node.inputs).length === 0;\n}\n\nexport function shouldBackProp(t: Tensor): boolean {\n  return !(t.node instanceof ConstantNode);\n}\n\nexport function isPassthroughNode(node: Node, map: TensorArrayMap): boolean {\n  const keys = Object.keys(node.inputs);\n  for (let i = 0; i < keys.length; i++) {\n    const input = node.inputs[keys[i]];\n    if (map.get(input, true) === map.get(node.output, true)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from './math/conv_util';\nimport * as gpgpu_util from './math/webgl/gpgpu_util';\nimport * as render_ndarray_gpu_util from './math/webgl/render_ndarray_gpu_util';\nimport * as webgl_util from './math/webgl/webgl_util';\nimport * as util from './util';\n\nexport {CheckpointLoader} from './checkpoint_loader';\nexport {DataStats, InMemoryDataset} from './dataset';\nexport {Graph, Tensor} from './graph';\nexport {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner';\nexport {ConstantInitializer, Initializer, NDArrayInitializer, OnesInitializer, RandomNormalInitializer, RandomTruncatedNormalInitializer, RandomUniformInitializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nexport {InCPUMemoryShuffledInputProviderBuilder, InGPUMemoryShuffledInputProviderBuilder, InputProvider} from './input_provider';\nexport {MatrixOrientation, NDArrayMath} from './math/math';\nexport {NDArrayMathCPU} from './math/math_cpu';\nexport {NDArrayMathGPU} from './math/math_gpu';\nexport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './math/ndarray';\nexport {GPGPUContext} from './math/webgl/gpgpu_context';\nexport {Optimizer} from './optimizer';\nexport {CostReduction, FeedEntry, Session} from './session';\nexport {SGDOptimizer} from './sgd_optimizer';\n// Second level exports.\nexport {conv_util, gpgpu_util, render_ndarray_gpu_util, util, webgl_util};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * Initializer interface, all initializer implement this interface.\n */\nexport interface Initializer {\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray;\n}\n\nexport class VarianceScalingInitializer implements Initializer {\n  constructor(\n      private scale = 1.0,\n      private mode: 'fan_in'|'fan_out'|'fan_avg' = 'fan_in',\n      private distribution: 'uniform'|'normal' = 'normal') {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    let n = 0;\n    if (this.mode === 'fan_in') {\n      n = inputUnits;\n    } else if (this.mode === 'fan_out') {\n      n = outputUnits;\n    } else if (this.mode === 'fan_avg') {\n      n = (inputUnits + outputUnits) / 2;\n    } else {\n      throw new Error(\n          'Unexpected mode for variance scaling initializer: ' + this.mode);\n    }\n\n    if (this.distribution === 'normal') {\n      return NDArray.randTruncatedNormal(\n          weightsShape, 0.0, Math.sqrt(this.scale / n));\n    } else if (this.distribution === 'uniform') {\n      return NDArray.randUniform(\n          weightsShape, 0.0, Math.sqrt(3 * this.scale / n));\n    } else {\n      throw new Error(\n          'Unexpected distribution for variance scaling initializer: ' +\n          this.distribution);\n    }\n  }\n}\n\nexport class ZerosInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.zeros(weightsShape);\n  }\n}\n\nexport class OnesInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(1);\n    return values;\n  }\n}\n\nexport class ConstantInitializer implements Initializer {\n  constructor(private value = 0) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(this.value);\n    return values;\n  }\n}\n\nexport class NDArrayInitializer implements Initializer {\n  constructor(private ndarray: NDArray) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return this.ndarray;\n  }\n}\n\nexport class RandomNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomTruncatedNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomUniformInitializer implements Initializer {\n  constructor(private minval = -.05, private maxval = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randUniform(weightsShape, this.minval, this.maxval);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * The interface for input providers.\n */\nexport interface InputProvider {\n  /**\n   * Get the next input as a copy. This is important because the data might\n   * get uploaded to the GPU and modify the original data.\n   * @param math NDArrayMath\n   */\n  getNextCopy(math: NDArrayMath): NDArray;\n  /**\n   * Dispose the input copy.\n   * @param math NDArrayMath\n   * @param copy The copy provided from getNextCopy\n   */\n  disposeCopy(math: NDArrayMath, copy: NDArray): void;\n}\n\n/**\n * A common interface for shuffled input provider builders. This returns\n * InputProviders that are synchronized.\n * @hidden\n */\nexport interface ShuffledInputProviderBuilder {\n  getInputProviders(): InputProvider[];\n}\n\n/**\n * @hidden\n */\nexport abstract class InMemoryShuffledInputProviderBuilder implements\n    ShuffledInputProviderBuilder {\n  protected shuffledIndices: Uint32Array;\n  protected numInputs: number;\n\n  protected idx = 0;\n  // Counter for how many times the current index has been called. Resets to 0\n  // when it reaches the number of inputs.\n  protected inputCounter = 0;\n  protected epoch = 0;\n\n  /**\n   * Constructs an `InMemoryShuffledInputProvider`. All of the inputs must be\n   * in memory.\n   * @param inputs All of the inputs, size: [number of inputs][number of\n   * examples].\n   */\n  constructor(protected inputs: NDArray[][]) {\n    this.shuffledIndices = util.createShuffledIndices(inputs[0].length);\n    this.numInputs = inputs.length;\n\n    // Make sure the number of examples in each input matches.\n    const numExamples = this.inputs[0].length;\n    for (let i = 0; i < this.numInputs; i++) {\n      util.assert(\n          this.inputs[i].length === numExamples,\n          'Number of examples must match across different inputs.');\n    }\n\n    // Make sure the shapes within inputs all match.\n    for (let i = 0; i < this.numInputs; i++) {\n      const inputShape = this.inputs[i][0].shape;\n      for (let j = 0; j < this.inputs[i].length; j++) {\n        util.assertShapesMatch(inputShape, this.inputs[i][j].shape);\n      }\n    }\n  }\n\n  protected getCurrentExampleIndex(): number {\n    const returnIdx = this.idx;\n\n    this.inputCounter++;\n    if (this.inputCounter >= this.numInputs) {\n      this.idx++;\n      this.inputCounter = 0;\n\n      if (this.idx >= this.inputs[0].length) {\n        this.idx = 0;\n        this.epoch++;\n      }\n    }\n    return returnIdx;\n  }\n\n  protected getNextInput(inputId: number): NDArray {\n    const currentExampleIndex = this.getCurrentExampleIndex();\n\n    return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]];\n  }\n\n  getEpoch() {\n    return this.epoch;\n  }\n\n  /**\n   * Returns input providers which shuffle the inputs and stay in sync.\n   */\n  getInputProviders(): InputProvider[] {\n    const inputProviders: InputProvider[] = [];\n\n    for (let i = 0; i < this.numInputs; i++) {\n      inputProviders.push(this.getInputProvider(i));\n    }\n    return inputProviders;\n  }\n\n  abstract getInputProvider(inputId: number): InputProvider;\n}\n\n/**\n * An in CPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * CPU and keeps them mutually in sync.\n */\nexport class InCPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return NDArray.like(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n\n/**\n * An in GPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * GPU and keeps them mutually in sync. This is more performant than the CPU\n * version as textures will stay in memory, however this is more GPU memory\n * intensive as it keeps textures resident in GPU memory.\n */\nexport class InGPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return math.clone(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/** A node's activation function and its derivative. */\nexport interface ActivationFunction {\n  output<T extends NDArray>(math: NDArrayMath, input: T): T;\n  der<T extends NDArray>(math: NDArrayMath, input: T, output: T): T;\n}\n\nexport class TanHFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.tanh(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      const ySquared = math.elementWiseMul(y, y);\n      // 1 - y^2.\n      return math.scalarMinusArray(Scalar.ONE, ySquared);\n    });\n  }\n}\n\nexport class ReLUFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.relu(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      return math.step(x);\n    });\n  }\n}\n\nexport class SigmoidFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.sigmoid(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // y * (1 - y) = y - y^2\n      const ySquared = math.elementWiseMul(y, y);\n      return math.sub(y, ySquared);\n    });\n  }\n}\n\nexport class SquareFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.elementWiseMul(x, x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // dy/dx = 2*x.\n      return math.scalarTimesArray(Scalar.TWO, x);\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function assertConcat3DShapesMatch(\n    x1Shape: number[], x2Shape: number[], axis: number,\n    errorMessagePrefix = '') {\n  util.assert(\n      x1Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.');\n  util.assert(\n      x2Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.');\n\n  util.assert(\n      axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.');\n\n  for (let i = 0; i < 3; i++) {\n    util.assert(\n        (i === axis) || (x1Shape[i] === x2Shape[i]),\n        errorMessagePrefix +\n            `Shape (${x1Shape}) does not match (${x2Shape}) along ` +\n            `non-concatenated axis.`);\n  }\n}\n\nexport function computeConcat3DOutputShape(\n    x1Shape: number[], x2Shape: number[],\n    axis: number): [number, number, number] {\n  util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.');\n  util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.');\n\n  const outputShape = x1Shape.slice();\n  outputShape[axis] += x2Shape[axis];\n  return outputShape as [number, number, number];\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function computeOutputShape3D(\n    inputShapeRowColDepth: [number, number, number], fieldSize: number,\n    depth: number, stride: number, zeroPad?: number): [number, number, number] {\n  if (zeroPad == null) {\n    zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride);\n  }\n  const inputRows = inputShapeRowColDepth[0];\n  const inputCols = inputShapeRowColDepth[1];\n  const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputRows),\n      `The output # of rows (${outputRows}) must be an integer. Change the ` +\n          `stride and/or zero pad parameters`);\n\n  const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputCols),\n      `The output # of columns (${outputCols}) must be an integer. Change ` +\n          `the stride and/or zero pad parameters`);\n\n  return [outputRows, outputCols, depth];\n}\n\nexport function computeDefaultPad(\n    inputShape: [number, number, number], fieldSize: number,\n    stride: number): number {\n  return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2);\n}\n\nexport function computeTexShapeFrom3D(\n    shapeRowColDepth: [number, number, number]): [number, number] {\n  return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]];\n}\n\nexport function computeWeightsShape4D(\n    inputDepth: number, outputDepth: number,\n    fSize: number): [number, number, number, number] {\n  return [fSize, fSize, inputDepth, outputDepth];\n}\n\nexport function computeWeightsTexShape(\n    inputDepth: number, outputDepth: number,\n    fieldSize: number): [number, number] {\n  return [fieldSize * fieldSize * inputDepth, outputDepth];\n}\n\nexport function computeBiasesTexShape(outputDepth: number): [number, number] {\n  return [1, outputDepth];\n}\n\nexport function computeDilatedRC(\n    rc: [number, number], origStride: number): [number, number] {\n  const rowsDilated = (rc[0] - 1) * origStride + 1;\n  const colsDilated = (rc[1] - 1) * origStride + 1;\n  return [rowsDilated, colsDilated];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function validateShapes(\n    sourceSize: [number, number], destSize: [number, number]) {\n  const srcArea = sourceSize[0] * sourceSize[1];\n  const dstArea = destSize[0] * destSize[1];\n  if (srcArea !== dstArea) {\n    const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']';\n    const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']';\n    throw new Error(\n        'copy2D shapes have different areas:\\n  sourceSize ' + srcStr +\n        ', area ' + srcArea + '\\n  destSize ' + dstStr + ', area ' + dstArea);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/**\n * An error function and its derivative.\n */\nexport interface ElementWiseCostFunction {\n  cost<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  der<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  dispose(): void;\n}\n\nexport class SquareCostFunc implements ElementWiseCostFunction {\n  private halfOne = Scalar.new(0.5);\n\n  cost(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    const diff = math.sub(x1, x2);\n    const diffSquared = math.elementWiseMul(diff, diff);\n    const result = math.scalarTimesArray(this.halfOne, diffSquared);\n\n    diff.dispose();\n    diffSquared.dispose();\n\n    return result;\n  }\n\n  der(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    return math.sub(x1, x2);\n  }\n\n  dispose() {\n    this.halfOne.dispose();\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2d_util from './copy2d_util';\n\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport type ScopeResult = NDArray[]|NDArray|void;\n\nexport abstract class NDArrayMath {\n  private ndarrayScopes: NDArray[][] = [];\n  private activeScope: NDArray[];\n\n  private ndarraysToKeep: NDArray[][] = [];\n  private activeScopeNDArraysToKeep: NDArray[] = [];\n\n  /**\n   * @param safeMode In safe mode, you must use math operations inside\n   * a math.scope() which will automatically clean up intermediate NDArrays.\n   */\n  constructor(private safeMode: boolean) {}\n\n  /**\n   * Create a new math scope. Put chained math operations inside a scope\n   * function closure so that the library automatically cleans up NDArrays\n   * from intermediate math operations. You must create a scope in safe mode\n   * to call math operations. If a result is returned from the scope, it will\n   * also be tracked, which means there must be yet another wrapping scope.\n   * @param scopeFn The function to execute with chained math operations.\n   */\n  scope<T extends ScopeResult>(\n      scopeFn:\n          (keep: <T1 extends NDArray>(ndarray: T1) => T1,\n           track: <T2 extends NDArray>(ndarray: T2) => T2) => T) {\n    this.startScope();\n\n    const keepFn = <T extends NDArray>(ndarray: T): T => this.keep(ndarray);\n    const trackFn = <T extends NDArray>(ndarray: T): T => this.track(ndarray);\n    const result = scopeFn(keepFn, trackFn);\n\n    this.endScope(result);\n\n    return result;\n  }\n\n  /**\n   * Start a scope. Use this with endScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  startScope() {\n    const newScope: NDArray[] = [];\n    this.ndarrayScopes.push(newScope);\n    this.activeScope = newScope;\n\n    const newNDArraysToKeep: NDArray[] = [];\n    this.ndarraysToKeep.push(newNDArraysToKeep);\n    this.activeScopeNDArraysToKeep = newNDArraysToKeep;\n  }\n\n  /**\n   * End a scope. Use this with startScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  endScope(result: ScopeResult) {\n    // Dispose the current scope.\n    for (let i = 0; i < this.activeScope.length; i++) {\n      const ndarray = this.activeScope[i];\n\n      if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) ||\n          (result != null && result instanceof NDArray &&\n           ndarray.getData() === (result as NDArray).getData())) {\n        continue;\n      }\n      ndarray.dispose();\n    }\n\n    // Pop the current scope.\n    this.ndarrayScopes.pop();\n    this.activeScope = this.ndarrayScopes.length === 0 ?\n        null! :\n        this.ndarrayScopes[this.ndarrayScopes.length - 1];\n\n    // Track the current result in the parent scope.\n    if (result instanceof NDArray &&\n        !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) {\n      this.track(result);\n    } else if (Array.isArray(result)) {\n      result.forEach(r => {\n        if (r instanceof NDArray &&\n            !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) {\n          this.track(r);\n        }\n      });\n    }\n\n    this.ndarraysToKeep.pop();\n    this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ?\n        null! :\n        this.ndarraysToKeep[this.ndarraysToKeep.length - 1];\n  }\n\n  private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) {\n    for (let i = 0; i < ndarrayList.length; i++) {\n      if (ndarrayList[i].getData() === ndarray.getData()) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Keeps an NDArray in the current scope from being disposed automatically.\n   * @param result The NDArray to keep from being disposed.\n   */\n  keep<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScopeNDArraysToKeep.push(result);\n    return result;\n  }\n\n  /**\n   * Tracks an NDArray in the current scope to be automatically cleaned up when\n   * the current scope ends, and returns the value.\n   * @param result The NDArray to track in the current scope.\n   */\n  track<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScope.push(result);\n    return result;\n  }\n\n  /**\n   * Computes the dot product of two matrices, A * B. These must be matrices,\n   * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct\n   * in other cases.\n   * @param a First matrix in dot product operation.\n   * @param b Second matrix in dot product operation.\n   * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will\n   * compute A^T * B.\n   * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will\n   * compute A * B^T.\n   */\n  matMul(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const innerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const innerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1];\n\n    util.assert(\n        a.rank === 2 && b.rank === 2,\n        `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` +\n            `and ${b.rank}.`);\n\n    util.assert(\n        innerShapeA === innerShapeB,\n        `Error in matMul: inner shapes (${innerShapeA}) and (` +\n            `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` +\n            `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` +\n            ` and ${MatrixOrientation[bOrientation]} must match.`);\n\n    return this.track(this.matMulInternal(a, b, aOrientation, bOrientation));\n  }\n  protected abstract matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D;\n\n  /**\n   * Computes the dot product of a vector and a matrix, v * B.\n   * @param v The vector in dot product operation.\n   * @param matrix The matrix in dot product operation.\n   */\n  vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: first input must be rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: second input must be rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[0],\n        `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `rank ${matrix.rank}.`);\n\n    return this.matMul(v.as2D(1, v.size), matrix).as1D();\n  }\n\n  /**\n   * Computes the dot product of a matrix and vector, A * v.\n   * @param matrix The matrix in dot product operation.\n   * @param v The vector in dot product operation.\n   */\n  matrixTimesVector(matrix: Array2D, v: Array1D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: second input must rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: first input must be a rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[1],\n        `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `shape ${matrix.shape}.`);\n\n    return this.matMul(matrix, v.as2D(v.size, 1)).as1D();\n  }\n\n  /**\n   * Computes the dot product of two vectors, v1 * v2.\n   * @param v1 The first vector in the dot product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  dotProduct(v1: Array1D, v2: Array1D): Scalar {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in dotProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n    util.assert(\n        v1.size === v2.size,\n        `Error in dotProduct: size of inputs (${v1.size}) and (` +\n            `${v2.size}) must match.`);\n    return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar();\n  }\n\n  /**\n   * Computes the outer product of two vectors, v1 and v2.\n   * @param v1 The first vector in the outer product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  outerProduct(v1: Array1D, v2: Array1D): Array2D {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in outerProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n\n    return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size));\n  }\n\n  ///////////////\n  // Shape ops //\n  ///////////////\n\n  /**\n   * Clones an NDArray of any shape.\n   * @param ndarray The NDArray to clone.\n   */\n  clone<T extends NDArray>(ndarray: T): T {\n    return this.track(this.cloneInternal(ndarray));\n  }\n  protected abstract cloneInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Reshapes an NDArray to a new shape. The size of the input NDArray must\n   * match the size of the requested shape.\n   * @param ndarray The input NDArray.\n   * @param newShape The new shape to reshape the NDArray to. Must be the same\n   * size as the NDArray.\n   */\n  reshape<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    util.assert(\n        ndarray.size === util.sizeFromShape(newShape),\n        `Error in reshape: old size ${ndarray.size} must match new size ` +\n            `${util.sizeFromShape(newShape)}.`);\n    return this.track(this.reshapeInternal<T1, T2>(ndarray, newShape));\n  }\n  protected abstract reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2;\n\n  /**\n   * Extracts a slice from a matrix. The operation extraces a slice from input\n   * that starts at coordinates `begin` and is of size `size`.\n   * @param input The input matrix to slice from.\n   * @param begin The 2D coordinates in the input matrix to start the slice\n   * from.\n   * @param size The sice of the 2D window to slice.\n   */\n  slice2D(input: Array2D, begin: [number, number], size: [number, number]):\n      Array2D {\n    util.assert(\n        begin[0] + size[0] <= input.shape[0] &&\n            begin[1] + size[1] <= input.shape[1],\n        `Error in slice2D: requested start position ${begin} and size ` +\n            `${size} would overflow input of shape ${input.shape}.`);\n    return this.track(this.slice2DInternal(input, begin, size));\n  }\n  protected abstract slice2DInternal(\n      input: Array2D, begin: [number, number], size: [number, number]): Array2D;\n\n  /**\n   * Copies a window from the `source` matrix starting at `sourceBegin` and is\n   * of size `sourceSize` to a window in the `dest` matrix starting at\n   * `destBegin` and is of size `destSize`/\n   * @param source The source matrix to copy from.\n   * @param sourceBegin The coordinates to start the copy from.\n   * @param sourceSize The size of the copy window.\n   * @param dest The destination matrix to copy to.\n   * @param destBegin The coordinates in `dest` to copy to.\n   * @param destSize The size of the destination window.\n   */\n  copy2D(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]) {\n    util.assert(\n        sourceBegin[0] + sourceSize[0] <= source.shape[0] &&\n            sourceBegin[1] + sourceSize[1] <= source.shape[1],\n        `Error in copy2D: requested source start position ${sourceBegin} ` +\n            `and source size ${sourceSize} would overflow source NDArray` +\n            `of shape ${source.shape}.`);\n    util.assert(\n        destBegin[0] + destSize[0] <= dest.shape[0] &&\n            destBegin[1] + destSize[1] <= dest.shape[1],\n        `Error in copy2D: requested dest start position ${destBegin} ` +\n            `and source size ${destSize} would overflow dest NDArray of` +\n            `shape ${dest.shape}.`);\n    copy2d_util.validateShapes(sourceSize, destSize);\n\n    return this.copy2DInternal(\n        source, sourceBegin, sourceSize, dest, destBegin, destSize);\n  }\n  protected abstract copy2DInternal(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]): void;\n\n  /**\n   * Concatenates two 3D ndarrays along a given axis.\n   *\n   * For example, if:\n   * A: shape(2, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *\n   * B: shape(2, 1, 3) = | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * C = concat3D(A, B, axis)\n   *\n   * if axis = 0:\n   * C: shape(4, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *                     | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * if axis = 1:\n   * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |\n   *                     | r2, g2, b2, r4, g4, b4 |\n   *\n   * if axis = 2:\n   * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |\n   *                      | r2, g2, b2, r4, g4, b4 |\n   *\n   * @param ndarray1 The first array to concat.\n   * @param ndarray2 The second array to conat.\n   * @param axis The axis to concate along.\n   */\n  concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D {\n    concat3d_util.assertConcat3DShapesMatch(\n        ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: ');\n    return this.track(this.concat3DInternal(ndarray1, ndarray2, axis));\n  }\n  protected abstract concat3DInternal(\n      ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D;\n\n  ///////////////////\n  // Reduction ops //\n  ///////////////////\n\n  /**\n   * Computes the the log(sum(e ^ x)) for each x in the input ndarray.\n   * @param ndarray The input NDArray to compute the logSumExp over.\n   */\n  logSumExp(ndarray: NDArray): Scalar {\n    return this.track(this.logSumExpInternal(ndarray));\n  }\n  protected abstract logSumExpInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the sum of all the entries in the input NDArray.\n   * @param ndarray The input NDArray to compute the sum over.\n   */\n  sum(ndarray: NDArray): Scalar {\n    return this.track(this.sumInternal(ndarray));\n  }\n  protected abstract sumInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the minimum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMin(ndarray: NDArray): Scalar {\n    return this.track(this.argMinInternal(ndarray));\n  }\n  protected abstract argMinInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the maximum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMax(ndarray: NDArray): Scalar {\n    return this.track(this.argMaxInternal(ndarray));\n  }\n  protected abstract argMaxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0.\n   * @param x1 The first input NDArray.\n   * @param x2 The second input NDArray.\n   */\n  argMaxEquals(x1: NDArray, x2: NDArray): Scalar {\n    util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: ');\n    return this.track(this.argMaxEqualsInternal(x1, x2));\n  }\n  protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar;\n\n  /**\n   * Computes the top K values and flattened indices.\n   * @param ndarray The input NDArray.\n   * @param k How many top values to compute.\n   */\n  topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} {\n    util.assert(\n        k <= ndarray.size,\n        `Error in topK: k value (${k}) must be less than size of input ` +\n            `ndarray, got shape ${ndarray.shape}.`);\n    const result = this.topKInternal(ndarray, k);\n    this.track(result.values);\n    this.track(result.indices);\n    return result;\n  }\n  protected abstract topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D};\n\n  /**\n   * Computes the minimum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  min(ndarray: NDArray): Scalar {\n    return this.track(this.minInternal(ndarray));\n  }\n  protected abstract minInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the maximum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  max(ndarray: NDArray): Scalar {\n    return this.track(this.maxInternal(ndarray));\n  }\n  protected abstract maxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the softmax normalized vector from the input vector.\n   * @param x The input vector.\n   */\n  softmax(x: Array1D): Array1D {\n    return this.scope(() => {\n      // Do it in log space for numerical stability.\n      // exp(X - logSumExp(X))\n      const lse = this.logSumExp(x);\n      const logResult = this.arrayMinusScalar(x, lse);\n      return this.exp(logResult);\n    });\n  }\n\n  //////////////////////\n  // Element-wise ops //\n  //////////////////////\n\n  /**\n   * Switches dimensions of the input NDArray.\n   * @param a The input NDArray.\n   * @param newDim The new indices that define which shapes values to switch.\n   */\n  switchDim<T extends NDArray>(a: T, newDim: number[]): T {\n    util.assert(\n        a.rank === newDim.length,\n        `Error in switchDim: length of input shape ${a.shape} ` +\n            `must match size of newDim array ${newDim}.`);\n    return this.track(this.switchDimInternal(a, newDim));\n  }\n  protected abstract switchDimInternal<T extends NDArray>(\n      a: T, newDim: number[]): T;\n\n  /**\n   * Computes a scalar plus NDArray, c + A.\n   * @param c The scalar c in c + A.\n   * @param a The NDArray A in c + A.\n   */\n  scalarPlusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarPlusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarPlusArrayInternal(c, a));\n  }\n  protected abstract scalarPlusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, c - A.\n   * @param c The scalar c in c - A.\n   * @param a The NDArray A in c - A.\n   */\n  scalarMinusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarMinusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarMinusArrayInternal(c, a));\n  }\n  protected abstract scalarMinusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, A - c.\n   * @param a The NDArray A in A - c.\n   * @param c The scalar c in A - c.\n   */\n  arrayMinusScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayMinusScalar: second argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.arrayMinusScalarInternal(a, c));\n  }\n  protected abstract arrayMinusScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes -1 * A element-wise.\n   * @param a The input array.\n   */\n  neg<T extends NDArray>(a: T): T {\n    return this.track(this.negInternal(a));\n  }\n  protected abstract negInternal<T extends NDArray>(a: T): T;\n\n  /**\n   * Adds two NDArrays element-wise, A + B. Inputs must be the same shape.\n   * @param a The first NDArray to add element-wise.\n   * @param b The second NDArray to add element-wise.\n   */\n  add<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in add: ');\n    return this.track(this.addInternal(a, b));\n  }\n  protected abstract addInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape.\n   * @param a The first NDArray to subtract element-wise.\n   * @param b The second NDArray to subtract element-wise.\n   */\n  sub<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in sub: ');\n    return this.track(this.subInternal(a, b));\n  }\n  protected abstract subInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must\n   * be the same shape.\n   * @param a The first NDArray to multiply element-wise.\n   * @param b The second NDArray to multiply element-wise.\n   */\n  elementWiseMul<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: ');\n    return this.track(this.elementWiseMulInternal(a, b));\n  }\n  protected abstract elementWiseMulInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be\n   * the same shape.\n   * @param a The first NDArray to divide element-wise.\n   * @param b The second NDArray to divide element-wise.\n   */\n  divide<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in divide: ');\n    return this.track(this.divideInternal(a, b));\n  }\n  protected abstract divideInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c /\n   * A.\n   * @param c The scalar value in c / A.\n   * @param a The NDArray value in c / A.\n   */\n  scalarDividedByArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarDividedByArray: first argument must be rank 0, but ` +\n            `got NDArray of rank ${c.rank}.`);\n    return this.track(this.scalarDividedByArrayInternal(c, a));\n  }\n  protected abstract scalarDividedByArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A /\n   * c.\n   * @param a The NDArray value in A / c.\n   * @param c The scalar value in A / c.\n   */\n  arrayDividedByScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: second argument must be rank 0, ` +\n            `but got NDArray of rank ${c.rank}.`);\n    return this.track(this.arrayDividedByScalarInternal(a, c));\n  }\n  protected abstract arrayDividedByScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes exponential of the input NDArray element-wise. y = e ^ x\n   * @param ndarray The input NDArray.\n   */\n  exp<T extends NDArray>(ndarray: T): T {\n    return this.track(this.expInternal(ndarray));\n  }\n  protected abstract expInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes natural logarithm of the input NDArray element-wise. y = ln(x)\n   * @param ndarray The input NDArray.\n   */\n  log<T extends NDArray>(ndarray: T): T {\n    return this.track(this.logInternal(ndarray));\n  }\n  protected abstract logInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes rectified linear element-wise, max(x, 0).\n   * @param ndarray The input NDArray.\n   */\n  relu<T extends NDArray>(ndarray: T): T {\n    return this.track(this.reluInternal(ndarray));\n  }\n  protected abstract reluInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)).\n   * @param ndarray The input NDArray.\n   */\n  sigmoid<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sigmoidInternal(ndarray));\n  }\n  protected abstract sigmoidInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes hyperbolic tangent of the input NDArray element-wise.\n   * @param ndarray The input NDArray.\n   */\n  tanh<T extends NDArray>(ndarray: T): T {\n    return this.track(this.tanhInternal(ndarray));\n  }\n  protected abstract tanhInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sin of the input NDArray element-wise, y = sin(x).\n   * @param ndarray The input NDArray.\n   */\n  sin<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sinInternal(ndarray));\n  }\n  protected abstract sinInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <=\n   * 0\n   * @param ndarray The input NDArray.\n   */\n  step<T extends NDArray>(ndarray: T): T {\n    return this.track(this.stepInternal(ndarray));\n  }\n  protected abstract stepInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes a scaled array add operation, c1 * A + c2 * B.\n   * @param c1 The first scalar in the scaled array add computation.\n   * @param a The first NDArray in the scaled array add computation.\n   * @param c2 The second scalar in the scaled array add computation.\n   * @param cb The second NDArray in the scaled array add computation.\n   */\n  scaledArrayAdd<T extends NDArray>(c1: Scalar, a: T, c2: Scalar, b: T): T {\n    util.assert(\n        c1.size === 1,\n        `Error in scaledArrayAdd: first argument must rank 0, but got ` +\n            ` rank ${c1.rank}.`);\n    util.assert(\n        c2.size === 1,\n        `Error in scaledArrayAdd: third argument must be rank 0, but got ` +\n            `NDArray of rank ${c2.rank}.`);\n    util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: ');\n\n    return this.track(this.scaledArrayAddInternal(c1, a, c2, b));\n  }\n  protected abstract scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T): T;\n\n  /**\n   * Computes a scalar times array operation broadcasted over the NDArray, c *\n   * A.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  scalarTimesArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: first argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.scalarTimesArrayInternal(c, a));\n  }\n  protected abstract scalarTimesArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an element-wise broadcasted multiplication of two matrices A and\n   * B. Will return a new matrix that is the max of A and B, where the smaller\n   * matrix will broadcast over the larger matrix.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D {\n    util.assert(\n        a.rank === 2,\n        `Error in elementWiseMulBroadcast: first argument must be ` +\n            `rank 2, but got rank ${a.rank}.`);\n    util.assert(\n        b.rank === 2,\n        `Error in elementWiseMulBroadcast: second argument must be ` +\n            `rank 2, but got rank ${b.rank}.`);\n    return this.track(this.elementWiseMulBroadcastInternal(a, b));\n  }\n  protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D):\n      Array2D;\n\n  /////////////////////\n  // Convolution ops //\n  /////////////////////\n\n  /**\n   * Computes a 2D convolution over the input x.\n   * @param x The input image, must be rank 3, of shape [rows, cols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param zeroPad The zero padding of each side of the input NDArray. Will pad\n   * equally on all sides.\n   */\n  conv2d(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2d: weights must be rank 4, but got rank ` +\n            `${weights.rank}.`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2d: biases must be rank 1, but got rank ` +\n              `${biases.rank}.`);\n    }\n\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2d: depth of input (${x.shape[2]}) must match  ` +\n            `input depth for weights ${weights.shape[2]}.`);\n\n\n    return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad));\n  }\n  protected abstract conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D;\n\n  /**\n   * Computes the backprop of a 2D convolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param stride The stride of the original convolution.\n   * @param pad The padding of the original convolution.\n   */\n  conv2dBackProp(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dBackProp: x must be rank 3, but got shape ` +\n            `${x.shape}.`);\n    util.assert(\n        dy.rank === 3,\n        `Error in conv2dBackProp: dy must be rank 3, but got shape ` +\n            `${dy.shape}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dBackProp: weights must be rank 4, but got shape ` +\n            `${weights.shape}.`);\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` +\n            `match input depth for weights (${weights.shape[2]}.`);\n    util.assert(\n        dy.shape[2] === weights.shape[3],\n        `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` +\n            `match output depth for weights (${weights.shape[3]}).`);\n\n    const backpropResult =\n        this.conv2dBackPropInternal(x, dy, weights, stride, pad);\n\n    this.track(backpropResult.db);\n    this.track(backpropResult.dw);\n    this.track(backpropResult.dx);\n\n    return backpropResult;\n  }\n  protected abstract conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D};\n\n  /**\n   * Computes the transposed 2D convolution of an image, also known as a\n   * deconvolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  conv2dTranspose(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dTranspose: x must be rank 3, but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dTranspose: weights must be rank 4, but got ` +\n            `rank ${weights.rank}`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2dTranspose: biases must be rank 1, but got ' +\n              'rank ${biases.rank}.`);\n    }\n    util.assert(\n        x.shape[2] === weights.shape[3],\n        `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` +\n            `match input depth for weights ${weights.shape[3]}.`);\n\n    return this.track(\n        this.conv2dTransposeInternal(x, weights, biases, stride, pad));\n  }\n  protected abstract conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D max pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.');\n    return this.track(this.maxPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the backprop of a max pool.\n   * @param dy The dy error.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPoolBackprop(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        dy.rank === 3,\n        `Error in maxPoolBackprop: dy must be rank 3 but got rank ` +\n            `${dy.rank}.`);\n    util.assert(\n        x.rank === 3,\n        `Error in maxPoolBackprop: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n\n    return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad));\n  }\n  protected abstract maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D min pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in minPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.minPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the 2D average pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.avgPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /*\n   * Bilinear resize a 3D array per each channel to a new 2D shape.\n   * @param x The input Array3D.\n   * @param newShape2D The new shape to resize the Array3D to. Each channel is\n   * resized individually.\n   * @param alignCorners An optional bool. Defaults to False. If true, rescale\n   * input by (new_height - 1) / (height - 1), which exactly aligns the 4\n   * corners of images and resized images. If false, rescale by new_height /\n   * height. Treat similarly the width dimension.\n   */\n  resizeBilinear3D(\n      x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`);\n    util.assert(\n        newShape2D.length === 2,\n        `Error in resizeBilinear3D: new shape must 2D, but got shape ` +\n            `${newShape2D}.`);\n    return this.track(\n        this.resizeBilinear3DInternal(x, newShape2D, alignCorners));\n  }\n  protected abstract resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D;\n\n  /**\n   * Batch normalization 3D. Mean, variance, scale, and offset can be of two\n   * shapes: 1) The same shape as the input: an Array3D. 2) In the common case,\n   * the depth dimension is the last dimension of x, so the values would be an\n   * Array1D of shape [depth].\n   * @param x The input NDArray.\n   * @param mean A mean NDArray.\n   * @param variance A variance NDArray.\n   * @param varianceEpsilon A small float number to avoid dividing by 0.\n   * @param scale A scale NDArray.\n   * @param offset An offset NDArray.\n   */\n  batchNormalization3D(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in batchNormalization3D: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        mean.rank === 3 || mean.rank === 1,\n        `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` +\n            `got rank ${mean.rank}.`);\n    util.assert(\n        variance.rank === 3 || variance.rank === 1,\n        `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` +\n            `but got rank ${variance.rank}.`);\n    if (scale != null) {\n      util.assert(\n          scale.rank === 3 || scale.rank === 1,\n          `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` +\n              `but got rank ${scale!.rank}.`);\n    }\n    if (offset != null) {\n      util.assert(\n          offset.rank === 3 || offset.rank === 1,\n          `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` +\n              `but got rank ${offset!.rank}.`);\n    }\n\n    return this.track(this.batchNormalization3DInternal(\n        x, mean, variance, varianceEpsilon, scale, offset));\n  }\n  protected abstract batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D;\n}\n\nexport enum MatrixOrientation {\n  REGULAR,\n  TRANSPOSED\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../math/conv_util';\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2D_util from './copy2d_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport class NDArrayMathCPU extends NDArrayMath {\n  constructor(safeMode = false) {\n    super(safeMode);\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    return NDArray.make<T>(\n        ndarray.shape, {values: new Float32Array(ndarray.getValues())});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    return this.cloneInternal(ndarray).reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = Array2D.zeros(sizeRowCol);\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol);\n    const srcValues = source.getValues();\n    const dstValues = dest.getValues();\n    const n = sourceSizeRowCol[0] * sourceSizeRowCol[1];\n    for (let i = 0; i < n; ++i) {\n      const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]);\n      const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]);\n      const srcOff = srcRow * source.shape[1] + srcCol;\n      const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]);\n      const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]);\n      const dstOff = dstRow * dest.shape[1] + dstCol;\n      dstValues[dstOff] = srcValues[srcOff];\n    }\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const outputShape =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const values = NDArray.zeros<Array3D>(outputShape);\n\n    for (let i = 0; i < outputShape[0]; i++) {\n      for (let j = 0; j < outputShape[1]; j++) {\n        for (let k = 0; k < outputShape[2]; k++) {\n          // Shader begins.\n          const index: [number, number, number] = [i, j, k];\n          let value: number;\n          if (index[axis] < x1.shape[axis]) {\n            value = x1.get(i, j, k);\n          } else {\n            index[axis] -= x1.shape[axis];\n            const [i2, j2, k2] = index;\n            value = x2.get(i2, j2, k2);\n          }\n\n          values.set(value, i, j, k);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const resultValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < resultValues.length; ++i) {\n      resultValues[i] = cVal + aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: resultValues});\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    const cValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    const c1Val = c1.get();\n    const c2Val = c2.get();\n    for (let i = 0; i < cValues.length; ++i) {\n      cValues[i] = c1Val * aValues[i] + c2Val * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: cValues});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cVal * aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const negA = this.negInternal(a);\n    const result = this.scalarPlusArrayInternal(c, negA);\n\n    negA.dispose();\n\n    return result;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    const negC = this.negInternal(c);\n    const result = this.scalarPlusArrayInternal(negC, a);\n\n    negC.dispose();\n\n    return result;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a);\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.ONE, b);\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.NEG_ONE, b);\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n\n    const leftDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const rightDim =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n\n    const normalGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(i, j);\n    const transposedGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(j, i);\n\n    const aGetter = (aOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const bGetter = (bOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const values = new Float32Array(leftDim * rightDim);\n    let index = 0;\n\n    for (let i = 0; i < leftDim; ++i) {\n      for (let j = 0; j < rightDim; ++j) {\n        let sum = 0;\n        for (let k = 0; k < sharedDim; ++k) {\n          // TODO: optimize CPU matmul.\n          sum += aGetter(a, i, k) * bGetter(b, k, j);\n        }\n        values[index++] = sum;\n      }\n    }\n    return Array2D.new([leftDim, rightDim], values);\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    const maxRow = Math.max(a.shape[0], b.shape[0]);\n    const maxCol = Math.max(a.shape[1], b.shape[1]);\n\n    const values = new Float32Array(maxRow * maxCol);\n    let index = 0;\n    for (let row = 0; row < maxRow; row++) {\n      for (let col = 0; col < maxCol; col++) {\n        values[index++] = a.get(row % a.shape[0], col % a.shape[1]) *\n            b.get(row % b.shape[0], col % b.shape[1]);\n      }\n    }\n    return Array2D.new([maxRow, maxCol], values);\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cValue / aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / cValue;\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    let sum = 0;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      sum += values[i];\n    }\n    return Scalar.new(sum);\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    let min = Number.MAX_VALUE;\n    let minIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n        minIndex = i;\n      }\n    }\n    return Scalar.new(minIndex);\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    let max = Number.NEGATIVE_INFINITY;\n    let maxIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n    return Scalar.new(maxIndex);\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    const argMax1 = this.argMaxInternal(x1).get();\n    const argMax2 = this.argMaxInternal(x2).get();\n    if (isNaN(argMax1) || isNaN(argMax2)) {\n      return Scalar.new(NaN);\n    }\n    return Scalar.new(+(argMax1 === argMax2));\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    const values = ndarray.getValues();\n    const valuesAndIndices: Array<{value: number, index: number}> = [];\n    for (let i = 0; i < values.length; i++) {\n      valuesAndIndices.push({value: values[i], index: i});\n    }\n    valuesAndIndices.sort((a, b) => {\n      return b.value - a.value;\n    });\n    const topkValues = new Float32Array(k);\n    const topkIndices = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n      topkValues[i] = valuesAndIndices[i].value;\n      topkIndices[i] = valuesAndIndices[i].index;\n    }\n    return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)};\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let min = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n      }\n    }\n    return Scalar.new(min);\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let max = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n      }\n    }\n    return Scalar.new(max);\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      newValues[i] = Math.exp(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      newValues[i] = Math.log(value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const xMax = this.max(ndarray);\n    const a = this.arrayMinusScalar(ndarray, xMax);\n    const b = this.exp(a);\n    const c = this.sum(b);\n    const d = this.log(c);\n    const result = this.add(xMax, d);\n\n    xMax.dispose();\n    a.dispose();\n    b.dispose();\n    c.dispose();\n    d.dispose();\n\n    return result;\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.max(0, values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = 1 / (1 + Math.exp(-values[i]));\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = util.tanh(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.sin(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    const [xRows, xCols, inputDepth] = x.shape;\n    const fieldSize = weights.shape[0];\n    const outputDepth = weights.shape[3];\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fieldSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fieldSize + xCCorner);\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              for (let d1 = 0; d1 < inputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight = weights.get(wR, wC, d1, d2);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = (biases != null) ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad);\n    return {dx, db, dw};\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const fSize = weights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR - pad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / origStride));\n        const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride);\n\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC - pad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / origStride));\n          const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride);\n\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR * origStride - xRCorner;\n\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC * origStride - xCCorner;\n\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = biases != null ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeShaderLike(\n      x: Array3D, origWeights: Array4D, origStride: number,\n      origPad: number): Array3D {\n    const fSize = origWeights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = origWeights.shape[2];\n    const origOutputDepth = origWeights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          // Shader code begins.\n          const xRCorner = yR - pad;\n          const xCCorner = yC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const xR = (xRCorner + wR) / origStride;\n            if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const xC = (xCCorner + wC) / origStride;\n              if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) {\n                continue;\n              }\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          y.set(dotProd, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    const dW = Array4D.zeros(weightsShape);\n\n    const yNumRows = dY.shape[0];\n    const yNumCols = dY.shape[1];\n    const xNumRows = x.shape[0];\n    const xNumCols = x.shape[1];\n\n    for (let wR = 0; wR < fSize; ++wR) {\n      const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride));\n      const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride);\n\n      for (let wC = 0; wC < fSize; ++wC) {\n        const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride));\n        const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride);\n\n        for (let d1 = 0; d1 < inputDepth; ++d1) {\n          for (let d2 = 0; d2 < outputDepth; ++d2) {\n            // Need to convolve.\n            let dotProd = 0;\n            for (let yR = yRMin; yR < yRMax; ++yR) {\n              const xR = wR + yR * stride - zeroPad;\n              for (let yC = yCMin; yC < yCMax; ++yC) {\n                const xC = wC + yC * stride - zeroPad;\n                dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2);\n              }\n            }\n            dW.set(dotProd, wR, wC, d1, d2);\n          }\n        }\n      }\n    }\n    return dW;\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const numRows = dY.shape[0];\n    const numCols = dY.shape[1];\n    const values = new Float32Array(outputDepth);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      let sum = 0;\n      for (let r = 0; r < numRows; ++r) {\n        for (let c = 0; c < numCols; ++c) {\n          sum += dY.get(r, c, d2);\n        }\n      }\n      values[d2] = sum;\n    }\n    return Array1D.new(values);\n  }\n\n  protected switchDimInternal<T extends NDArray>(t: T, newDim: number[]): T {\n    const newShape: number[] = new Array(t.rank);\n    for (let i = 0; i < newShape.length; i++) {\n      newShape[i] = t.shape[newDim[i]];\n    }\n    const resultValues = new Float32Array(t.size);\n    const values = t.getValues();\n    const result = NDArray.make<T>(newShape, {values: resultValues});\n    for (let i = 0; i < t.size; ++i) {\n      const loc = t.indexToLoc(i);\n\n      // Permute location.\n      const newLoc: number[] = new Array(loc.length);\n      for (let i = 0; i < newLoc.length; i++) {\n        newLoc[i] = loc[newDim[i]];\n      }\n\n      const newIndex = result.locToIndex(newLoc);\n      resultValues[newIndex] = values[i];\n    }\n    return result;\n  }\n\n  private pool(\n      x: Array3D, fSize: number, stride: number, pad: number,\n      poolType: 'max'|'min'|'avg') {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, depth], fSize, depth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n\n\n          let minMaxValue =\n              (poolType === 'max' ? Number.NEGATIVE_INFINITY :\n                                    Number.POSITIVE_INFINITY);\n          let avgValue = 0;\n\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (isNaN(pixel)) {\n                minMaxValue = NaN;\n                avgValue = NaN;\n                break;\n              }\n              if ((poolType === 'max' && pixel > minMaxValue) ||\n                  (poolType === 'min' && pixel < minMaxValue)) {\n                minMaxValue = pixel;\n              } else if (poolType === 'avg') {\n                avgValue += pixel / (fSize * fSize);\n              }\n            }\n            if (isNaN(minMaxValue)) {\n              break;\n            }\n          }\n          y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'max');\n  }\n\n  maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad);\n    const maxPositions = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < outputShape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < outputShape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n          let maxValue = Number.NEGATIVE_INFINITY;\n          let maxPosition = -1;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (pixel > maxValue) {\n                maxValue = pixel;\n                maxPosition = wR * fSize + wC;\n              }\n            }\n          }\n          maxPositions.set(maxPosition, yR, yC, d);\n        }\n      }\n    }\n    return maxPositions;\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad);\n    const pad = fSize - 1 - origPad;\n    const [dyRows, dyCols, depth] = dy.shape;\n\n    // Dilate the input.\n    const dyRowsDilated = (dyRows - 1) * origStride + 1;\n    const dxColsDilated = (dyCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad);\n    const dx = Array3D.zeros(outputShape);\n\n    for (let d = 0; d < depth; ++d) {\n      for (let dxR = 0; dxR < dx.shape[0]; ++dxR) {\n        for (let dxC = 0; dxC < dx.shape[1]; ++dxC) {\n          // Shader code begins.\n          const dyRCorner = dxR - pad;\n          const dyCCorner = dxC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const dyR = (dyRCorner + wR) / origStride;\n            if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const dyC = (dyCCorner + wC) / origStride;\n              if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) {\n                continue;\n              }\n              const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d);\n              const curPos = wR * fSize + wC;\n\n              const mask = maxPos === curPos ? 1 : 0;\n              if (mask === 0) {\n                continue;\n              }\n\n              const pixel = dy.get(dyR, dyC, d);\n              dotProd += pixel * mask;\n            }\n          }\n          dx.set(dotProd, dxR, dxC, d);\n        }\n      }\n    }\n    return dx;\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'min');\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'avg');\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]);\n\n    const effectiveInputSize =\n        alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape;\n    const effectiveOutputSize = alignCorners ?\n        [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] :\n        output.shape;\n    for (let r = 0; r < output.shape[0]; r++) {\n      for (let c = 0; c < output.shape[1]; c++) {\n        for (let d = 0; d < output.shape[2]; d++) {\n          // Begin shader.\n\n          // Compute the fractional index of the source.\n          const sourceFracRow =\n              (effectiveInputSize[0]) * r / (effectiveOutputSize[0]);\n          const sourceFracCol =\n              (effectiveInputSize[1]) * c / (effectiveOutputSize[1]);\n\n          const sourceRowFloor = Math.floor(sourceFracRow);\n          const sourceRowCeil =\n              Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow));\n          const sourceColFloor = Math.floor(sourceFracCol);\n          const sourceColCeil =\n              Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol));\n\n          const topLeft = x.get(sourceRowFloor, sourceColFloor, d);\n          const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d);\n          const topRight = x.get(sourceRowFloor, sourceColCeil, d);\n          const bottomRight = x.get(sourceRowCeil, sourceColCeil, d);\n\n          const rowFrac = sourceFracRow - sourceRowFloor;\n          const colFrac = sourceFracCol - sourceColFloor;\n\n          const top = topLeft + (topRight - topLeft) * colFrac;\n          const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;\n          const newValue = top + (bottom - top) * rowFrac;\n\n          output.set(newValue, r, c, d);\n        }\n      }\n    }\n\n    return output;\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xValues = x.getValues();\n    const meanValues = mean.getValues();\n    const varianceValues = variance.getValues();\n    const scaleValues = scale ? scale.getValues() : new Float32Array([1]);\n    const offsetValues = offset ? offset.getValues() : new Float32Array([0]);\n    const outValues = new Float32Array(xValues.length);\n\n    for (let i = 0; i < xValues.length; i++) {\n      outValues[i] = offsetValues[i % offsetValues.length] +\n          (xValues[i] - meanValues[i % meanValues.length]) *\n              scaleValues[i % scaleValues.length] /\n              Math.sqrt(\n                  varianceValues[i % varianceValues.length] + varianceEpsilon);\n    }\n    return NDArray.make<Array3D>(x.shape, {values: outValues});\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as conv_util from './conv_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport * as ndarray from './ndarray';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\nimport * as addscaledmat_gpu from './webgl/addscaledmat_gpu';\nimport * as addsubmuldiv_gpu from './webgl/addsubmuldiv_gpu';\nimport {OperandType} from './webgl/addsubmuldiv_gpu';\nimport * as argmaxequals_gpu from './webgl/argmaxequals_gpu';\nimport * as argminmax_gpu from './webgl/argminmax_gpu';\nimport * as avg_pool_gpu from './webgl/avg_pool_gpu';\nimport * as batchnorm_gpu from './webgl/batchnorm_gpu';\nimport * as concat3d_gpu from './webgl/concat3d_gpu';\nimport * as conv_backprop_gpu from './webgl/conv_backprop_gpu';\nimport * as conv_gpu from './webgl/conv_gpu';\nimport * as copy_gpu from './webgl/copy_gpu';\nimport * as exp_gpu from './webgl/exp_gpu';\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport * as gpgpu_util from './webgl/gpgpu_util';\nimport * as log_gpu from './webgl/log_gpu';\nimport * as logsumexp_gpu from './webgl/logsumexp_gpu';\nimport * as max_pool_backprop_gpu from './webgl/max_pool_backprop_gpu';\nimport * as max_pool_gpu from './webgl/max_pool_gpu';\nimport * as min_pool_gpu from './webgl/min_pool_gpu';\nimport * as minmax_gpu from './webgl/minmax_gpu';\nimport * as mulmat_gpu from './webgl/mulmat_gpu';\nimport * as neg_gpu from './webgl/neg_gpu';\nimport * as pool_gpu from './webgl/pool_gpu';\nimport * as reducesum_gpu from './webgl/reducesum_gpu';\nimport * as relu_gpu from './webgl/relu_gpu';\nimport * as reshape_gpu from './webgl/reshape_gpu';\nimport * as resize_bilinear_gpu from './webgl/resize_bilinear_gpu';\nimport * as shader_compiler from './webgl/shader_compiler';\nimport * as sigmoid_gpu from './webgl/sigmoid_gpu';\nimport * as step_gpu from './webgl/step_gpu';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as trig_gpu from './webgl/trig_gpu';\nimport * as webgl_util from './webgl/webgl_util';\n\nconst ARGMAX_PROG = 'argmax';\nconst ARGMAX_EQUALS_PROG = 'argmaxequals';\nconst ARGMIN_PROG = 'argmin';\n\nconst BATCHNORM_PROG = 'batchnorm';\n\nconst COPY_PROG = 'copy';\nconst CONCAT_PROG = 'concat';\n\n// Matrix algebra.\nconst ADD_SCALED_MAT_PROG = 'addscaledmat';\nconst MATMUL_PROG = 'matmul';\n\n// Element-wise ops.\nconst RELU_PROG = 'relu';\nconst TANH_PROG = 'tanh';\nconst SIN_PROG = 'sin';\nconst SIGMOID_PROG = 'sigmoid';\nconst MAX_PROG = 'max';\nconst MIN_PROG = 'min';\nconst NEG_PROG = 'neg';\nconst EXP_PROG = 'exp';\nconst LOG_PROG = 'log';\nconst SUM_PROG = 'sum';\nconst STEP_PROG = 'step';\nconst LOGSUMEXP_PROG = 'logsumexp';\nconst RESHAPE_PROG = 'reshape';\nconst ADD_SUM_MUL_DIV_PROG = 'addsummuldiv';\n\n// Convolution.\nconst CONV2D_PROG = 'conv';\nconst CONV2D_TRANSPOSE_PROG = 'conv_transpose';\nconst CONV2D_DERW_PROG = 'conv_derw';\nconst CONV2D_DERB_PROG = 'conv_derb';\nconst MAX_POOL_PROG = 'maxpool';\nconst MAX_POOL_POSITIONS_PROG = 'maxpool_posn';\nconst MAX_POOL_BACKPROP_PROG = 'maxpool_backprop';\nconst MIN_POOL_PROG = 'minpool';\nconst AVG_POOL_PROG = 'avgpool';\n\nconst RESIZE_BILINEAR_PROG = 'resizebilin';\n\nfunction makeCopyProgramName(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  const shapeName = `${sourceShapeRowCol[0]}_${sourceShapeRowCol[1]}`;\n  const srcSizeName = `${sourceSizeRowCol[0]}_${sourceSizeRowCol[1]}`;\n  const dstSizeName = `${destSizeRowCol[0]}_${destSizeRowCol[1]}`;\n  return `${COPY_PROG}_${shapeName}_${srcSizeName}_${dstSizeName}`;\n}\n\nexport class NDArrayMathGPU extends NDArrayMath {\n  private gpgpu: GPGPUContext;\n  private textureManager: TextureManager;\n  private programCache: {[key: string]: WebGLProgram} = {};\n  private gpgpuCreatedLocally: boolean;\n\n  constructor(gpgpu?: GPGPUContext, safeMode = true) {\n    super(safeMode);\n    if (gpgpu == null) {\n      const gl = gpgpu_util.createWebGLContext();\n      this.gpgpu = new GPGPUContext(gl);\n      this.gpgpuCreatedLocally = true;\n    } else {\n      this.gpgpu = gpgpu;\n      this.gpgpuCreatedLocally = false;\n    }\n\n    this.textureManager = new TextureManager(this.gpgpu);\n\n    ndarray.initializeGPU(this.gpgpu, this.textureManager);\n  }\n\n  getGPGPUContext(): GPGPUContext {\n    return this.gpgpu;\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC),\n        () => copy_gpu.getFragmentShaderSource(\n            textureShapeRC, textureShapeRC, textureShapeRC));\n\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    copy_gpu.copy(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0],\n        textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    let newTexShape: [number, number];\n\n    switch (newShape.length) {\n      case 0:\n        newTexShape = [1, 1];\n        break;\n      case 1:\n        newTexShape = [newShape[0], 1];\n        break;\n      case 2:\n        newTexShape = [newShape[0], newShape[1]];\n        break;\n      case 3:\n        newTexShape = [newShape[0], newShape[1] * newShape[2]];\n        break;\n      default:\n        throw Error(\n            `Reshapes into ${newShape.length}-dim ndarray is not yet ` +\n            `supported on GPU`);\n    }\n\n    const actualTexShape = ndarray.getTextureShapeRC(newTexShape);\n    let clonedArray: T1;\n    if (!util.arraysEqual(actualTexShape, newTexShape)) {\n      clonedArray = this.reshapeTexture(ndarray, newTexShape);\n    } else {\n      clonedArray = this.cloneInternal(ndarray);\n    }\n    return clonedArray.reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = NDArray.make<Array2D>(sizeRowCol, {\n      texture: this.textureManager.acquireTexture(sizeRowCol),\n      textureShapeRC: sizeRowCol\n    });\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    const sourceShapeRC = source.getTextureShapeRC();\n    const destShapeRC = dest.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol),\n        () => copy_gpu.getFragmentShaderSource(\n            sourceShapeRC, sourceSizeRowCol, destSizeRowCol));\n\n    copy_gpu.copy(\n        this.gpgpu, program, source.getTexture(), sourceShapeRC,\n        sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC,\n        destBeginRowCol, destSizeRowCol);\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const x1TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x1.shape);\n    const x2TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x2.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC);\n    let cleanupX1 = false;\n    if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) {\n      x1 = this.reshapeTexture(x1, x1TexShapeRC);\n      cleanupX1 = true;\n    }\n    const actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC);\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) {\n      x2 = this.reshapeTexture(x2, x2TexShapeRC);\n      cleanupX2 = true;\n    }\n\n    const resultShapeRCD =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const program = this.getAndSaveProgram(\n        `${CONCAT_PROG}_${x1.shape}_${x2.shape}_${axis}`,\n        () => concat3d_gpu.getFragmentShaderSource(\n            x1.shape, x2.shape, resultShapeRCD, axis));\n\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    concat3d_gpu.concat3D(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX1) {\n      x1.dispose();\n    }\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '+', OperandType.MATRIX) as T;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    return this.addSubMulDiv(\n        a, c, a.shape, OperandType.MATRIX, '-', OperandType.SCALAR) as T;\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '-', OperandType.MATRIX) as T;\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    let cleanupB = false;\n    if (!this.doGPUShapesMatch(a, b)) {\n      b = this.reshapeTexture(b, a.getTextureShapeRC());\n      cleanupB = true;\n    }\n\n    const program = this.getAndSaveProgram(\n        ADD_SCALED_MAT_PROG, () => addscaledmat_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    addscaledmat_gpu.addScaledMatrices(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n    // Bring the result back to the original shape.\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '*', OperandType.MATRIX) as T;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    const program = this.getAndSaveProgram(\n        NEG_PROG, () => neg_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    neg_gpu.neg(\n        this.gpgpu, program, a.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  private reshapeTexture<T extends NDArray>(a: T, newTextureShape: [\n    number, number\n  ]): T {\n    const aTexShape = a.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        RESHAPE_PROG, () => reshape_gpu.getFragmentShaderSource());\n\n    const resultTexture = this.textureManager.acquireTexture(newTextureShape);\n    reshape_gpu.reshape(\n        this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1],\n        resultTexture, newTextureShape[0], newTextureShape[1]);\n\n    return NDArray.make<T>(\n        a.shape, {texture: resultTexture, textureShapeRC: newTextureShape});\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const outerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const outerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n    const outShape: [number, number] = [outerShapeA, outerShapeB];\n    const outTexShape =\n        webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape);\n    const outTexture = this.textureManager.acquireTexture(outTexShape);\n    const out = new Array2D(\n        outShape, {texture: outTexture, textureShapeRC: outTexShape});\n\n    const key = shader_compiler.makeShaderKey([a, b], out);\n    const program = this.getAndSaveProgram(\n        `${MATMUL_PROG}_${key}_${aOrientation}_${bOrientation}`,\n        () => mulmat_gpu.getFragmentShader(\n            a, b, out, aOrientation, bOrientation));\n\n    mulmat_gpu.multiplyMatrix(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture,\n        outTexShape);\n\n    return out;\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '*', OperandType.MATRIX) as T;\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xTexShape = x.getTextureShapeRC();\n\n    let cleanupMean = false;\n    const preferredMeanTexShape: [number, number] =\n        mean.rank === 1 ? [1, mean.size] : xTexShape;\n    let meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) {\n      mean = this.reshapeTexture(mean, preferredMeanTexShape);\n      meanTexShape = preferredMeanTexShape;\n      cleanupMean = true;\n    }\n\n    let cleanupVariance = false;\n    const preferredVarianceTexShape: [number, number] =\n        variance.rank === 1 ? [1, variance.size] : xTexShape;\n    let varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) {\n      variance = this.reshapeTexture(variance, preferredVarianceTexShape);\n      varianceTexShape = preferredVarianceTexShape;\n      cleanupVariance = true;\n    }\n\n    let scaleTexShape: [number, number]|null = null;\n    let cleanupScale = false;\n    if (scale != null) {\n      const preferredScaleTexShape: [number, number] =\n          scale.rank === 1 ? [1, scale.size] : xTexShape;\n\n      scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape);\n      if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) {\n        scale = this.reshapeTexture(scale, preferredScaleTexShape);\n        scaleTexShape = preferredScaleTexShape;\n        cleanupScale = true;\n      }\n    }\n\n    let offsetTexShape: [number, number]|null = null;\n    let cleanupOffset = false;\n    if (offset != null) {\n      const preferredOffsetTexShape: [number, number] =\n          offset.rank === 1 ? [1, offset.size] : xTexShape;\n\n      offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape);\n      if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) {\n        offset = this.reshapeTexture(offset, preferredOffsetTexShape);\n        offsetTexShape = preferredOffsetTexShape;\n        cleanupOffset = true;\n      }\n    }\n\n    const resultTexShape: [number, number] = x.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${BATCHNORM_PROG}_${xTexShape}_${meanTexShape}_${varianceTexShape}_` +\n            `${scaleTexShape!}_${offsetTexShape!}_${varianceEpsilon}`,\n        () => batchnorm_gpu.getFragmentShaderSource(\n            xTexShape, meanTexShape, varianceTexShape, offsetTexShape,\n            scaleTexShape, varianceEpsilon));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    batchnorm_gpu.batchNormalization(\n        this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(),\n        meanTexShape, variance.getTexture(), varianceTexShape,\n        offset != null ? offset.getTexture() : null,\n        offset != null ? offsetTexShape : null,\n        scale != null ? scale.getTexture() : null,\n        scale != null ? scaleTexShape : null, resultTexture, resultTexShape);\n\n    if (cleanupMean) {\n      mean.dispose();\n    }\n    if (cleanupVariance) {\n      variance.dispose();\n    }\n    if (cleanupScale) {\n      scale!.dispose();\n    }\n    if (cleanupOffset) {\n      offset!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        x.shape, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  protected switchDimInternal<T extends NDArray>(a: T, newDim: number[]): T {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${SUM_PROG}_${numRows}_${numColumns}`,\n        () => reducesum_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMIN_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    // If the texture shapes doesn't match, do a physical reshape so they do.\n    const actualX1TexShape = x1.getTextureShapeRC();\n    const actualX2TexShape = x2.getTextureShapeRC();\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) {\n      x2 = this.reshapeTexture(x2, actualX1TexShape);\n      cleanupX2 = true;\n    }\n\n    const textureShapeRC = x1.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_EQUALS_PROG}_${numRows}_${numColumns}`,\n        () => argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(\n            numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argmaxequals_gpu.argMaxEquals(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows,\n        numColumns, resultTexture);\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    throw new Error('topK GPU not yet implemented!');\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MIN_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MAX_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '/', OperandType.MATRIX) as T;\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    return this.addSubMulDiv(\n               c, a, a.shape, OperandType.SCALAR, '/', OperandType.MATRIX) as T;\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    return this.addSubMulDiv(\n               a, c, a.shape, OperandType.MATRIX, '/', OperandType.SCALAR) as T;\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '+', OperandType.MATRIX) as T;\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '-', OperandType.MATRIX) as T;\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const [numRows, numColumns] = ndarray.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${LOGSUMEXP_PROG}_${numRows}_${numColumns}`,\n        () => logsumexp_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const result =\n        new Scalar({texture: this.textureManager.acquireTexture([1, 1])});\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        result.getTexture());\n\n    return result;\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        EXP_PROG, () => exp_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    exp_gpu.exp(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        LOG_PROG, () => log_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n    log_gpu.log(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        RELU_PROG, () => relu_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    relu_gpu.relu(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIGMOID_PROG, () => sigmoid_gpu.getSigmoidFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    sigmoid_gpu.sigmoid(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        TANH_PROG, () => trig_gpu.getTanhFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.tanh(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIN_PROG, () => trig_gpu.getSinFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.sin(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        STEP_PROG, () => step_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    step_gpu.step(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    const fieldSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const progKey = [\n      CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_gpu.getFragmentShaderSource(\n          x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(outputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    const resultShape = conv_util.computeOutputShape3D(\n        x.shape, fieldSize, outputDepth, stride, zeroPad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_gpu.convolve(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB && biases != null) {\n      biases.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const yTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupX = false;\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dy.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dy = this.reshapeTexture(dy, yTexShape);\n      cleanupY = true;\n    }\n\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(\n        dy, weights, null /** biases */, stride, pad);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupY) {\n      dy.dispose();\n    }\n    return {dx, db, dw};\n  }\n\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const fieldSize = weights.shape[0];\n\n    const progKey = [\n      CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride,\n      origPad, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderConvTransposeSource(\n          x.shape, fieldSize, origInputDepth, origStride, origPad,\n          biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape = conv_util.computeWeightsTexShape(\n        origInputDepth, origOutputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(origInputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBiasTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    // Figure out the output shape by dilating the input.\n    const dilatedRC =\n        conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride);\n    const pad = fieldSize - 1 - origPad;\n    const resultShape = conv_util.computeOutputShape3D(\n        [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize,\n        origInputDepth, 1, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.convTranspose(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB) {\n      biases!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const progKey = [\n      CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerWeightsSource(\n          x.shape, fSize, outputDepth, stride, zeroPad);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const yShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, outputDepth, stride, zeroPad);\n    const yTexShape = conv_util.computeTexShapeFrom3D(yShape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derWeights(\n        this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    return NDArray.make<Array4D>(\n        weightsShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const progKey = [CONV2D_DERB_PROG, dY.shape].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape);\n    });\n    const yTexShape = conv_util.computeTexShapeFrom3D(dY.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape = conv_util.computeBiasesTexShape(outputDepth);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derBias(\n        this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape);\n\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    return NDArray.make<Array1D>(\n        [outputDepth], {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  private pool(\n      program: WebGLProgram, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    const resultShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const poolResultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    pool_gpu.poolCommon(\n        this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: poolResultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const maxPoolProgKey =\n        [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, () => {\n      return max_pool_gpu.getFragmentShaderMaxPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(maxPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const minPoolProgKey =\n        [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const minPoolProgram = this.getAndSaveProgram(minPoolProgKey, () => {\n      return min_pool_gpu.getFragmentShaderMinPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(minPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const avgPoolProgKey =\n        [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, () => {\n      return avg_pool_gpu.getFragmentShaderAvgPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(avgPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPoolPositionsProgKey = [\n      MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad\n    ].join('_');\n    const maxPoolPositionsProgram =\n        this.getAndSaveProgram(maxPoolPositionsProgKey, () => {\n          return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(\n              x.shape, fSize, origStride, origPad);\n        });\n\n    const maxPoolResultShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, x.shape[2], origStride, origPad);\n    const maxPoolResultTexShape =\n        conv_util.computeTexShapeFrom3D(maxPoolResultShape);\n    const maxPoolPositionsResultTex =\n        this.textureManager.acquireTexture(maxPoolResultTexShape);\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    max_pool_gpu.maxPoolCommon(\n        this.gpgpu, maxPoolPositionsProgram, x.getTexture(),\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    const maxPoolBackpropProgKey = [\n      MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad\n    ].join('_');\n    const program = this.getAndSaveProgram(maxPoolBackpropProgKey, () => {\n      return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(\n          dy.shape, fSize, origStride, origPad);\n    });\n\n    const dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualDyTexShape = dy.getTextureShapeRC(dyTexShape);\n    let cleanupDy = false;\n    if (!util.arraysEqual(actualDyTexShape, dyTexShape)) {\n      dy = this.reshapeTexture(dy, dyTexShape);\n      cleanupDy = true;\n    }\n\n    const dilatedDyRC =\n        conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride);\n    const pad = fSize - 1 - origPad;\n    const resultShapeRCD = conv_util.computeOutputShape3D(\n        [dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1,\n        pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    max_pool_backprop_gpu.maxPoolBackprop(\n        this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex,\n        resultTex, resultTexShape);\n\n    if (cleanupDy) {\n      dy.dispose();\n    }\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    this.textureManager.releaseTexture(\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const programKey =\n        [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_');\n\n    const newShapeRCD: [number, number, number] =\n        [newShape2D[0], newShape2D[1], x.shape[2]];\n    const resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD);\n\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => resize_bilinear_gpu.getFragmentShaderSource(\n            x.shape, newShape2D, alignCorners));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    resize_bilinear_gpu.resizeBilinear(\n        this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape);\n\n    return NDArray.make<Array3D>(\n        newShapeRCD, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  private getAndSaveProgram(programKey: string, getShaderSource: () => string):\n      WebGLProgram {\n    if (!(programKey in this.programCache)) {\n      this.programCache[programKey] =\n          this.gpgpu.createProgram(getShaderSource());\n    }\n    return this.programCache[programKey];\n  }\n\n  private addSubMulDiv(\n      a: NDArray, b: NDArray, resultShape: number[],\n      operandA: addsubmuldiv_gpu.OperandType,\n      opType: addsubmuldiv_gpu.Operation,\n      operandB: addsubmuldiv_gpu.OperandType): NDArray {\n    let cleanupB = false;\n\n    const aOrientation = MatrixOrientation.REGULAR;\n    let bOrientation = MatrixOrientation.REGULAR;\n\n    let logicalBTexShape: [number, number];\n\n    if (operandA === OperandType.MATRIX && operandB === OperandType.MATRIX) {\n      util.assertShapesMatch(a.shape, b.shape);\n\n      if (a.inGPU()) {\n        // Prefer B to have the shape of A.\n        b.getTextureShapeRC(a.getTextureShapeRC());\n      } else if (b.inGPU()) {\n        // Prefer A to have the shape of B.\n        a.getTextureShapeRC(b.getTextureShapeRC());\n      }\n\n      const aTexShape = a.getTextureShapeRC();\n      const bTexShape = b.getTextureShapeRC();\n      logicalBTexShape = bTexShape;\n\n      if (a.rank === 1) {\n        // When dealing with vectors, we can sample in transposed way without\n        // the need to do physical reshape.\n        if (!util.arraysEqual(bTexShape, aTexShape)) {\n          bOrientation = MatrixOrientation.TRANSPOSED;\n          logicalBTexShape = [bTexShape[1], bTexShape[0]];\n        }\n      }\n\n      if (!util.arraysEqual(aTexShape, logicalBTexShape)) {\n        b = this.reshapeTexture(b, aTexShape);\n        bOrientation = MatrixOrientation.REGULAR;\n        logicalBTexShape = b.getTextureShapeRC();\n        cleanupB = true;\n      }\n    } else {\n      logicalBTexShape = b.getTextureShapeRC();\n    }\n\n    const aTexShape = a.getTextureShapeRC();\n    const bTexShape = b.getTextureShapeRC();\n\n    const programKey = [\n      ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB,\n      bOrientation\n    ].join('_');\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => addsubmuldiv_gpu.getFragmentShaderSource(\n            operandA, aOrientation, opType, operandB, bOrientation));\n\n    const resultTextureShape: [number, number] = [\n      Math.max(aTexShape[0], logicalBTexShape[0]),\n      Math.max(aTexShape[1], logicalBTexShape[1])\n    ];\n\n    const resultTexture =\n        this.textureManager.acquireTexture(resultTextureShape);\n\n    addsubmuldiv_gpu.addSubMulDiv(\n        this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(),\n        bTexShape, resultTexture, resultTextureShape);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n\n    return NDArray.make(\n        resultShape,\n        {texture: resultTexture, textureShapeRC: resultTextureShape});\n  }\n\n  private doGPUShapesMatch(a: NDArray, b: NDArray): boolean {\n    util.assertShapesMatch(a.shape, b.shape);\n    if (a.inGPU()) {\n      // Prefer B to have the shape of A.\n      b.getTextureShapeRC(a.getTextureShapeRC());\n    } else if (b.inGPU()) {\n      // Prefer A to have the shape of B.\n      a.getTextureShapeRC(b.getTextureShapeRC());\n    }\n    return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC());\n  }\n\n  getTextureManager(): TextureManager {\n    return this.textureManager;\n  }\n\n  dispose() {\n    for (const programKey in this.programCache) {\n      if (this.programCache.hasOwnProperty(programKey)) {\n        this.gpgpu.deleteProgram(this.programCache[programKey]);\n      }\n    }\n    this.textureManager.dispose();\n\n    if (this.gpgpuCreatedLocally) {\n      this.gpgpu.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as webgl_util from './webgl/webgl_util';\n\n// These global variables need to be initialized to null so that closure knows\n// not to seal them.\n/** @hidden */\nexport let GPGPU: GPGPUContext = null!;\n/** @hidden */\nexport let TEXTURE_MANAGER: TextureManager = null!;\n\n/** @hidden */\nexport interface NDArrayData {\n  values?: Float32Array;\n  texture?: WebGLTexture;\n  /** [rows, columns] shape of the texture. */\n  textureShapeRC?: [number, number];\n}\n\n/** @hidden */\nexport function initializeGPU(\n    gpgpu: GPGPUContext, textureManager: TextureManager) {\n  GPGPU = gpgpu;\n  TEXTURE_MANAGER = textureManager;\n}\n\nfunction throwIfGPUNotInitialized() {\n  if (GPGPU == null || TEXTURE_MANAGER == null) {\n    throw new Error('GPU not intialized.');\n  }\n}\n\nexport class NDArray {\n  /** The shape of the ndarray. */\n  shape: number[];\n  /** Number of elements in the ndarray. */\n  size: number;\n\n  /**\n   * Number of elements to skip in each dimension when indexing. See\n   * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html\n   */\n  protected strides: number[];\n\n  private data: NDArrayData;\n\n  protected constructor(shape: number[], data: NDArrayData) {\n    // Sanity checks.\n    util.assert(\n        data.values != null || data.texture != null,\n        'Either `values` or `texture` must be defined');\n\n    util.assert(\n        data.texture == null || (data.textureShapeRC != null),\n        '`textureShape` must be defined when `texture` is defined');\n\n    this.size = util.sizeFromShape(shape);\n\n    if (data.values != null) {\n      util.assert(\n          this.size === data.values.length,\n          'Constructing ndarray of shape (' + this.size + ') should match the' +\n              ' length of values (' + data.values.length + ')');\n    }\n\n    this.shape = shape;\n    this.data = data;\n    const dim = this.shape.length;\n\n    if (dim < 2) {\n      this.strides = [];\n    } else {\n      // Last dimension has implicit stride of 1, thus having D-1 (instead of D)\n      // strides.\n      this.strides = new Array(dim - 1);\n      this.strides[dim - 2] = this.shape[dim - 1];\n      for (let i = dim - 3; i >= 0; --i) {\n        this.strides[i] = this.strides[i + 1] * this.shape[i + 1];\n      }\n    }\n  }\n\n  /** Creates a ndarray of zeros with the specified shape. */\n  static zeros<T extends NDArray>(shape: number[]): T {\n    const values = new Float32Array(util.sizeFromShape(shape));\n    return NDArray.make<T>(shape, {values});\n  }\n\n  /** Creates a ndarray of zeros with the same shape as the specified ndarray.\n   */\n  static zerosLike<T extends NDArray>(another: T): T {\n    return NDArray.zeros(another.shape) as T;\n  }\n\n  /** Creates a ndarray with the same values/shape as the specified ndarray. */\n  static like<T extends NDArray>(another: T): T {\n    const values = another.getValues();\n    return NDArray.make<T>(another.shape, {values: new Float32Array(values)});\n  }\n\n  /**\n   * Makes a new ndarray with the provided shape and values. Values should be in\n   * a flat array.\n   */\n  static make<T extends NDArray>(shape: number[], data: NDArrayData): T {\n    switch (shape.length) {\n      case 0:\n        return new Scalar(data) as T;\n      case 1:\n        // tslint:disable-next-line:no-any\n        return new Array1D(data) as any;\n      case 2:\n        // tslint:disable-next-line:no-any\n        return new Array2D(shape as [number, number], data) as any;\n      case 3:\n        // tslint:disable-next-line:no-any\n        return new Array3D(shape as [number, number, number], data) as any;\n      case 4:\n        return new Array4D(\n                   // tslint:disable-next-line:no-any\n                   shape as [number, number, number, number], data) as any;\n      default:\n        // tslint:disable-next-line:no-any\n        return new NDArray(shape, data) as any;\n    }\n  }\n\n  /** Reshapes the current ndarray into the provided shape. */\n  reshape<T extends NDArray>(newShape: number[]): T {\n    if (util.arraysEqual(this.shape, newShape)) {\n      // No-op.\n      // tslint:disable-next-line:no-any\n      return this as any;\n    }\n\n    util.assert(\n        this.size === util.sizeFromShape(newShape),\n        'new shape and old shape must have the same number of elements.');\n\n    return NDArray.make<T>(newShape, this.data);\n  }\n\n  asScalar(): Scalar {\n    util.assert(this.size === 1, 'The array must have only 1 element.');\n    return this.reshape<Scalar>([]);\n  }\n\n  as1D(): Array1D {\n    return this.reshape<Array1D>([this.size]);\n  }\n\n  as2D(rows: number, columns: number): Array2D {\n    return this.reshape<Array2D>([rows, columns]);\n  }\n\n  as3D(rows: number, columns: number, depth: number): Array3D {\n    return this.reshape<Array3D>([rows, columns, depth]);\n  }\n\n  as4D(rows: number, columns: number, depth: number, depth2: number): Array4D {\n    return this.reshape<Array4D>([rows, columns, depth, depth2]);\n  }\n\n  get rank(): number {\n    return this.shape.length;\n  }\n\n  get(...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return this.getValues()[index];\n  }\n\n  add(value: number, ...locs: number[]) {\n    this.set(this.get(...locs) + value, ...locs);\n  }\n\n  set(value: number, ...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    this.getValues()[index] = value;\n  }\n\n  locToIndex(locs: number[]): number {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return index;\n  }\n\n  indexToLoc(index: number): number[] {\n    const locs: number[] = new Array(this.shape.length);\n    for (let i = 0; i < locs.length - 1; ++i) {\n      locs[i] = Math.floor(index / this.strides[i]);\n      index -= locs[i] * this.strides[i];\n    }\n    locs[locs.length - 1] = index;\n    return locs;\n  }\n\n  fill(value: number) {\n    this.getValues().fill(value);\n  }\n\n  getData(): NDArrayData {\n    return this.data;\n  }\n\n  getValues(): Float32Array {\n    if (this.data.values == null) {\n      throwIfGPUNotInitialized();\n      this.data.values = GPGPU.downloadMatrixFromTexture(\n          this.data.texture!, this.data.textureShapeRC![0],\n          this.data.textureShapeRC![1]);\n      this.disposeTexture();\n    }\n    return this.data.values;\n  }\n\n  private uploadToGPU(preferredTexShape?: [number, number]) {\n    throwIfGPUNotInitialized();\n    this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(\n        GPGPU.gl, this.shape, preferredTexShape);\n    this.data.texture =\n        TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC);\n\n    GPGPU.uploadMatrixToTexture(\n        this.data.texture, this.data.textureShapeRC[0],\n        this.data.textureShapeRC[1], this.data.values!);\n\n    this.data.values = null!;\n  }\n\n  getTexture(preferredShapeRC?: [number, number]): WebGLTexture {\n    if (this.data.texture == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.texture!;\n  }\n\n  getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] {\n    if (this.data.textureShapeRC == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.textureShapeRC!;\n  }\n\n  dispose(): void {\n    this.data.values = null!;\n    this.shape = null!;\n    if (this.data.texture != null) {\n      this.disposeTexture();\n    }\n  }\n\n  private disposeTexture() {\n    throwIfGPUNotInitialized();\n    TEXTURE_MANAGER.releaseTexture(\n        this.data.texture!, this.data.textureShapeRC!);\n    this.data.texture = null!;\n    this.data.textureShapeRC = null!;\n  }\n\n  inGPU(): boolean {\n    return this.data.texture != null;\n  }\n\n  equals(t: NDArray): boolean {\n    return util.arraysEqual(this.shape, t.shape) &&\n        util.arraysEqual(this.getValues(), t.getValues());\n  }\n\n  static rand<T extends NDArray>(shape: number[], randFunction: () => number):\n      T {\n    const size = util.sizeFromShape(shape);\n    const values = new Float32Array(size);\n    for (let i = 0; i < size; i++) {\n      values[i] = randFunction();\n    }\n\n    return NDArray.make<T>(shape, {values});\n  }\n\n  static randNormal<T extends NDArray>(shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev));\n  }\n\n  static randTruncatedNormal<T extends NDArray>(\n      shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev, true));\n  }\n\n  static randUniform<T extends NDArray>(shape: number[], a: number, b: number) {\n    return NDArray.rand<T>(shape, () => util.randUniform(a, b));\n  }\n}\n\nexport class Scalar extends NDArray {\n  constructor(data: NDArrayData) {\n    if (data.texture != null) {\n      data.textureShapeRC = [1, 1];\n    }\n    super([], data);\n  }\n\n  static new(value: number) {\n    return new Scalar({values: new Float32Array([value])});\n  }\n\n  static ZERO = Scalar.new(0);\n  static ONE = Scalar.new(1);\n  static TWO = Scalar.new(2);\n  static NEG_ONE = Scalar.new(-1);\n\n  get(): number {\n    return this.getValues()[0];\n  }\n\n  set(value: number) {\n    this.getValues()[0] = value;\n  }\n\n  add(value: number) {\n    this.getValues()[0] += value;\n  }\n}\n\nexport class Array1D extends NDArray {\n  shape: [number];\n\n  constructor(data: NDArrayData) {\n    const shape = (data.values != null) ?\n        [data.values.length] :\n        [util.sizeFromShape(data.textureShapeRC!)];\n    super(shape, data);\n  }\n\n  static new(values: Float32Array|number[]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      util.assert(\n          inferredShape.length === 1,\n          `Error constructing Array1D. Shape of values ${inferredShape} is ` +\n              `not 1 dimensional.`);\n    }\n    return new Array1D({values: toTypedArray(values)});\n  }\n\n  get(i: number): number {\n    return this.getValues()[i];\n  }\n\n  set(value: number, i: number) {\n    this.getValues()[i] = value;\n  }\n\n  add(value: number, i: number) {\n    this.getValues()[i] += value;\n  }\n\n  locToIndex(loc: [number]): number {\n    return loc[0];\n  }\n\n  indexToLoc(index: number): [number] {\n    return [index];\n  }\n\n  static zeros(shape: [number]): Array1D {\n    return NDArray.zeros<Array1D>(shape);\n  }\n}\n\nexport class Array2D extends NDArray {\n  shape: [number, number];\n\n  private stride0: number;\n\n  constructor(shape: [number, number], data: NDArrayData) {\n    util.assert(shape.length === 2, 'Shape should be of length 2');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n  }\n\n  static new(\n      shape: [number, number], values: Float32Array|number[]|number[][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array2D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array2D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number) {\n    return this.getValues()[this.stride0 * i + j];\n  }\n\n  set(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] = value;\n  }\n\n  add(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] += value;\n  }\n\n  locToIndex(locs: [number, number]): number {\n    return this.stride0 * locs[0] + locs[1];\n  }\n\n  indexToLoc(index: number): [number, number] {\n    return [Math.floor(index / this.stride0), index % this.stride0];\n  }\n\n  static zeros(shape: [number, number]): Array2D {\n    return NDArray.zeros<Array2D>(shape);\n  }\n}\n\nexport class Array3D extends NDArray {\n  shape: [number, number, number];\n  private stride0: number;\n  private stride1: number;\n\n  constructor(shape: [number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 3, 'Shape should be of length 3');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n  }\n\n  static new(\n      shape: [number, number, number],\n      values: Float32Array|number[]|number[][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array3D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array3D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number) {\n    return this.getValues()[this.stride0 * i + this.stride1 * j + k];\n  }\n\n  set(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] += value;\n  }\n\n  locToIndex(locs: [number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2];\n  }\n\n  indexToLoc(index: number): [number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    return [i, Math.floor(index / this.stride1), index % this.stride1];\n  }\n\n  static zeros(shape: [number, number, number]): Array3D {\n    return NDArray.zeros<Array3D>(shape);\n  }\n}\n\nexport class Array4D extends NDArray {\n  shape: [number, number, number, number];\n  private stride0: number;\n  private stride1: number;\n  private stride2: number;\n\n  constructor(shape: [number, number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 4, 'Shape should be of length 4');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n    this.stride2 = this.strides[2];\n  }\n\n  static new(\n      shape: [number, number, number, number],\n      values: Float32Array|number[]|number[][][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array4D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array4D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number, l: number) {\n    return this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l];\n  }\n\n  set(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value;\n  }\n\n  locToIndex(locs: [number, number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] +\n        this.stride2 * locs[2] + locs[3];\n  }\n\n  indexToLoc(index: number): [number, number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    const j = Math.floor(index / this.stride1);\n    index -= j * this.stride1;\n    return [i, j, Math.floor(index / this.stride2), index % this.stride2];\n  }\n\n  static zeros(shape: [number, number, number, number]): Array4D {\n    return NDArray.zeros<Array4D>(shape);\n  }\n}\n\ntype ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][];\n\nfunction toTypedArray(a: ArrayData): Float32Array {\n  return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a));\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    uniform sampler2D matrixAScalar;\n    uniform sampler2D matrixBScalar;\n    varying vec2 resultUV;\n\n    const vec2 halfTexel = vec2(0.5, 0.5);\n\n    void main() {\n      float a = texture2D(matrixA, resultUV).r;\n      float b = texture2D(matrixB, resultUV).r;\n      float aScalar = texture2D(matrixAScalar, halfTexel).r;\n      float bScalar = texture2D(matrixBScalar, halfTexel).r;\n      vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n      gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n    }`;\n}\n\nexport function addScaledMatrices(\n    gpgpu: GPGPUContext, addScaledMatricesProgram: WebGLProgram,\n    a: WebGLTexture, b: WebGLTexture, rows: number, columns: number,\n    aScalar: WebGLTexture, bScalar: WebGLTexture, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(addScaledMatricesProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2);\n  gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3);\n  gpgpu.executeProgram();\n}\n\nexport function uploadAddScaledMatricesDownload(\n    a: Float32Array, b: Float32Array, rows: number, columns: number,\n    aScalar: number, bScalar: number): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource());\n\n  const aTex = gpgpu.createMatrixTexture(rows, columns);\n  const bTex = gpgpu.createMatrixTexture(rows, columns);\n  const aScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const bScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const resultTex = gpgpu.createMatrixTexture(rows, columns);\n\n  gpgpu.uploadMatrixToTexture(aTex, rows, columns, a);\n  gpgpu.uploadMatrixToTexture(bTex, rows, columns, b);\n  gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar]));\n  gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar]));\n\n  addScaledMatrices(\n      gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex,\n      resultTex);\n\n  const result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns);\n\n  gpgpu.deleteMatrixTexture(aTex);\n  gpgpu.deleteMatrixTexture(bTex);\n  gpgpu.deleteMatrixTexture(resultTex);\n  gpgpu.deleteMatrixTexture(aScalarTex);\n  gpgpu.deleteMatrixTexture(bScalarTex);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\n\nimport * as binaryop_gpu from './binaryop_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport type Operation = '+' | '-' | '*' | '/';\n\nexport enum OperandType {\n  MATRIX,\n  SCALAR\n}\n\nexport function getFragmentShaderSource(\n    aType: OperandType, aOrientation: MatrixOrientation, op: Operation,\n    bType: OperandType, bOrientation: MatrixOrientation): string {\n  const aUV = operandToShaderSnippet(aType, aOrientation);\n  const bUV = operandToShaderSnippet(bType, bOrientation);\n  const resultOp = `gl_FragColor = vec4(a ${op} b, 0, 0, 0);`;\n  return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp);\n}\n\nfunction operandToShaderSnippet(\n    operand: OperandType, orientation: MatrixOrientation): string {\n  switch (operand) {\n    case OperandType.MATRIX:\n      return 'resultUV' +\n          (orientation === MatrixOrientation.REGULAR ? '.st' : '.ts');\n    case OperandType.SCALAR:\n      return 'vec2(0.5, 0.5)';\n    default:\n      throw new Error('Unknown operand type');\n  }\n}\n\nexport function addSubMulDiv(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  return binaryop_gpu.binaryOp(\n      gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result,\n      resultShapeRowCol);\n}\n\nexport function uploadScalarPlusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '+', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixMinusScalarDownload(\n    a: Float32Array, aShape: [number, number], b: number,\n    aOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR,\n      MatrixOrientation.REGULAR);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      a, aShape, new Float32Array([b]), [1, 1], src);\n}\n\nexport function uploadScalarMinusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '-', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadScalarTimesMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '*', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixTimesMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n\nexport function uploadMatrixPlusMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as argminmax_gpu from './argminmax_gpu';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      float argMaxA = getArgMinMax(matrixA);\n      float argMaxB = getArgMinMax(matrixB);\n      float value;\n      if (isNaN(argMaxA)) {\n        value = argMaxA;\n      } else if (isNaN(argMaxB)) {\n        value = argMaxB;\n      } else {\n        value = float(argMaxA == argMaxB);\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getArgMaxEqualsFragmentShaderSource(\n    rows: number, columns: number): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function argMaxEquals(\n    gpgpu: GPGPUContext, maxEqualsProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, numRows: number, numCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(maxEqualsProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n    }`;\n}\n\nfunction getArgMinMaxFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    getFragmentShaderGetArgMinMaxSource(compOp, rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function getArgMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '<');\n}\n\nexport function getArgMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '>');\n}\n\nexport function getFragmentShaderGetArgMinMaxSource(\n    compOp: string, rows: number, columns: number) {\n  return `\n    const vec2 dimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    float getArgMinMax(in sampler2D matrix) {\n      vec2 bestCR = vec2(0, 0);\n      float bestValue = texture2D(matrix, bestCR).r;\n\n      for (float c = 0.0; c < dimCR.x; c += 1.0) {\n        for (float r = 0.0; r < dimCR.y; r += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / dimCR;\n          float value = texture2D(matrix, uv).r;\n          if (isNaN(value)) {\n            return value;\n          }\n          if (value ${compOp} bestValue) {\n            bestValue = value;\n            bestCR = cr;\n          }\n        }\n      }\n      return bestCR.x + (bestCR.y * dimCR.x);\n    }\n  `;\n}\n\nexport function argMinMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderAvgPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'avg', false);\n}\n\nexport function avgPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    xTexShapeRC: [number, number], meanTexShapeRC: [number, number],\n    varianceTexShapeRC: [number, number],\n    offsetTexShapeRC: [number, number]|null,\n    scaleTexShapeRC?: [number, number]|null, varianceEpsilon = 0.001): string {\n  let offsetSamplerSnippet = '';\n  let offsetShapeInitializationSnippet = '';\n  let offsetCoordsSnippet = '';\n  let offsetUVSnippet = '';\n  let offsetValueSnippet = '';\n  let offsetOperationSnippet = '0.0';\n\n  let scaleSamplerSnippet = '';\n  let scaleShapeInitializationSnippet = '';\n  let scaleCoordsSnippet = '';\n  let scaleUVSnippet = '';\n  let scaleValueSnippet = '';\n  let scaleOperationSnippet = '';\n\n  if (offsetTexShapeRC != null) {\n    offsetSamplerSnippet = 'uniform sampler2D offset;';\n    offsetShapeInitializationSnippet = `const vec2 offsetShapeCR = vec2(\n            ${offsetTexShapeRC[1]}, ${offsetTexShapeRC[0]});`;\n    offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);';\n    offsetUVSnippet =\n        'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;';\n    offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;';\n    offsetOperationSnippet = 'offsetValue';\n  }\n\n  if (scaleTexShapeRC != null) {\n    scaleSamplerSnippet = 'uniform sampler2D scale;';\n    scaleShapeInitializationSnippet = `const vec2 scaleShapeCR = vec2(\n            ${scaleTexShapeRC[1]}, ${scaleTexShapeRC[0]});`;\n    scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);';\n    scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;';\n    scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;';\n    scaleOperationSnippet = 'inv *= scaleValue;';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D mean;\n    uniform sampler2D variance;\n    ${offsetSamplerSnippet}\n    ${scaleSamplerSnippet}\n\n    varying vec2 resultUV;\n\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 meanShapeCR = vec2(${meanTexShapeRC[1]}, ${meanTexShapeRC[0]});\n    const vec2 varianceShapeCR = vec2(\n        ${varianceTexShapeRC[1]}, ${varianceTexShapeRC[0]});\n\n    ${offsetShapeInitializationSnippet}\n    ${scaleShapeInitializationSnippet}\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const float varianceEpsilon = ${varianceEpsilon};\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n      vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n      ${offsetCoordsSnippet}\n      ${scaleCoordsSnippet}\n\n      vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n      vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n      ${offsetUVSnippet}\n      ${scaleUVSnippet}\n\n      float xValue = texture2D(x, resultUV).r;\n      float meanValue = texture2D(mean, meanUV).r;\n      float varianceValue = texture2D(variance, varianceUV).r;\n      ${offsetValueSnippet}\n      ${scaleValueSnippet}\n\n      float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n      ${scaleOperationSnippet}\n      float xTimesInv = xValue * inv;\n      float meanTimesInvWithOffset = ${offsetOperationSnippet}\n          - meanValue * inv;\n\n      gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n    }`;\n}\n\nexport function batchNormalization(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    xShapeRowCol: [number, number], mean: WebGLTexture,\n    meanShapeRowCol: [number, number], variance: WebGLTexture,\n    varianceShapeRowCol: [number, number], offset: WebGLTexture|null,\n    offsetShapeRowCol: [number, number]|null, scale: WebGLTexture|null,\n    scaleShapeRowCol: [number, number]|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.setInputMatrixTexture(mean, 'mean', 1);\n  gpgpu.setInputMatrixTexture(variance, 'variance', 2);\n  let nextIndex = 3;\n  if (offset != null) {\n    gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex);\n    nextIndex++;\n  }\n  if (scale != null) {\n    gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    aResultUV: string, bResultUV: string, op: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;\n\n    void main() {\n      float a = texture2D(matrixA, ${aResultUV}).r;\n      float b = texture2D(matrixB, ${bResultUV}).r;\n      ${op}\n    }`;\n}\n\nexport function binaryOp(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n\nexport function uploadBinaryOpDownload(\n    a: Float32Array, aShape: [number, number], b: Float32Array,\n    bShape: [number, number], fragmentShaderSource: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(fragmentShaderSource);\n\n  const aTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(aShape[0], aShape[1]);\n  const bTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(bShape[0], bShape[1]);\n\n  const resultShape: [number, number] =\n      [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])];\n\n  const resultTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(resultShape[0], resultShape[1]);\n\n  gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a);\n  gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b);\n\n  binaryOp(\n      gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture,\n      resultShape);\n  const result = gpgpu.downloadMatrixFromTexture(\n      resultTexture, resultShape[0], resultShape[1]);\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    x1ShapeRCD: [number, number, number], x2ShapeRCD: [number, number, number],\n    resultShapeRCD: [number, number, number], axis: number): string {\n  const x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD);\n  const x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD);\n\n  const yAxes = ['yR', 'yC', 'yD'];\n  const concatAxis = yAxes[axis];\n\n  return `\n    precision highp float;\n    uniform sampler2D x1;\n    uniform sampler2D x2;\n\n    const vec2 x1ShapeCR = vec2(${x1TexShapeRC[1]}, ${x1TexShapeRC[0]});\n    const vec2 x2ShapeCR = vec2(${x2TexShapeRC[1]}.0, ${x2TexShapeRC[0]}.0);\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${resultShapeRCD[2]}.0);\n      float yD = mod(yTexCR.x, ${resultShapeRCD[2]}.0);\n\n      float value = 0.0;\n\n      if (${concatAxis} < ${x1ShapeRCD[axis]}.0) {\n        // Map yR, yC, yD back to x1 coordinates.\n        vec2 x1CR = vec2(yC * ${x1ShapeRCD[2]}.0 + yD, yR);\n        vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n        value = texture2D(x1, x1UV).r;\n      } else {\n        ${concatAxis} = ${concatAxis} - ${x1ShapeRCD[axis]}.0;\n\n        // Map yR, yC, yD back to x2 coordinates.\n        vec2 x2CR = vec2(yC * ${x2ShapeRCD[2]}.0 + yD, yR);\n        vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n        value = texture2D(x2, x2UV).r;\n      }\n\n      gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function concat3D(\n    gpgpu: GPGPUContext, program: WebGLProgram, x1: WebGLTexture,\n    x2: WebGLTexture, result: WebGLTexture, resultShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x1, 'x1', 0);\n  gpgpu.setInputMatrixTexture(x2, 'x2', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport * as conv_gpu from './conv_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderDerWeightsSource(\n    xShapeRowColDepth: [number, number, number], fSize: number,\n    outputDepth: number, stride: number, zeroPad: number) {\n  const getMatrixValueOrZeroPad =\n      conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const inputDepth = xShapeRowColDepth[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth);\n\n  const yShape = conv_util.computeOutputShape3D(\n      xShapeRowColDepth, fSize, outputDepth, stride, zeroPad);\n  const yNumRows = yShape[0];\n  const yNumCols = yShape[1];\n  const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape);\n\n  const fSizeTimesInputDepth = fSize * inputDepth;\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D dy;\n  `;\n\n  return prologue + '\\n' + getMatrixValueOrZeroPad + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]});\n\n    void main() {\n      vec2 wTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n      float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0);\n      float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0;\n      float wC = floor(wTexRLeftover / ${inputDepth}.0);\n      float d1 = mod(wTexRLeftover, ${inputDepth}.0);\n      float d2 = wTexCR.x;\n\n      // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float xR = wR + yR * ${stride}.0 - ${zeroPad}.0;\n        float xTexR = xR;\n        float yTexR = yR;\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          float xC = wC + yC * ${stride}.0 - ${zeroPad}.0;\n\n          // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) +\n                        vec2(d1, d2);\n          float xTexC = xyTexC.x;\n          float yTexC = xyTexC.y;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read x(xR, xC, d1) (potentially zero-padded).\n          float xValue =\n            getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n          dotProd += (xValue * dyValue);\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderConvTransposeSource(\n    xShapeRCD: [number, number, number], fSize: number, origInputDepth: number,\n    origStride: number, origPad: number, hasBias: boolean) {\n  const pad = fSize - 1 - origPad;\n  const [xRows, xCols, origOutputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize);\n\n  const getBiasValue = hasBias ?\n      conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) :\n      '';\n  const biasPrologue = hasBias ? 'uniform sampler2D biases;' : '';\n  const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : '';\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    ${biasPrologue}\n    `;\n\n  return prologue + '\\n' + getBiasValue + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${origInputDepth}.0);\n      float d2 = mod(yTexCR.x, ${origInputDepth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float xR = (xRCorner + wR) / ${origStride}.0;\n        // TODO(smilkov): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) {\n          continue;\n        }\n\n        float wRPerm = ${fSize}.0 - 1.0 - wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float xC = (xCCorner + wC) / ${origStride}.0;\n          if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) {\n            continue;\n          }\n\n          float wCPerm = ${fSize}.0 - 1.0 - wC;\n          float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 +\n                        wCPerm * ${origInputDepth}.0 + d2;\n\n          for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${origOutputDepth}.0 + d1;\n            float wTexC = d1;\n\n            // Read x(xR, xC, d1).\n            vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n            float xValue = texture2D(x, xUV).r;\n\n            // Read w(wRPerm, wCPerm, d2, d1).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      ${biasOperation}\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderDerBiasSource(\n    dyShapeRCD: [number, number, number]) {\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const [yNumRows, yNumCols, outputDepth] = dyShapeRCD;\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n      // The bias texture RC shape is [1, d2].\n      float d2 = biasTexCR.x;\n\n      float derBias = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float yTexR = yR;\n\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          float yTexC = yC * ${outputDepth}.0 + d2;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          derBias += dyValue;\n        }\n      }\n      gl_FragColor = vec4(derBias, 0, 0, 0);\n    }`;\n}\n\nexport function derBias(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    result: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.executeProgram();\n}\n\nexport function derWeights(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    dyTex: WebGLTexture, result: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 1);\n  gpgpu.executeProgram();\n}\n\nexport function convTranspose(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    weightsTex: WebGLTexture, biasesTex: WebGLTexture|null,\n    resultTex: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1);\n  if (biasesTex != null) {\n    gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    uniform sampler2D biases;\n    varying vec2 resultUV;`;\n}\n\nexport function getFragmentShaderGetMatrixValueOrZeroPadSource(): string {\n  return `\n    float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n        vec2 requestedCR) {\n      vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n      float value = texture2D(matrix, uv).r;\n      bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n      bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n      bool outside = lessThanZero || greaterThanOne;\n      return mix(value, 0.0, float(outside));\n    }`;\n}\n\nexport function getFragmentShaderConvolveSource(\n    xShapeRCD: [number, number, number], fSize: number, outputDepth: number,\n    stride: number, pad: number, hasBias: boolean) {\n  const [xRows, xCols, inputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n\n  return `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${outputDepth}.0);\n      float d2 = mod(yTexCR.x, ${outputDepth}.0);\n      float wTexC = d2;\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n\n          for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${inputDepth}.0 + d1;\n            float wTexR = wR * ${fSize * inputDepth}.0 +\n                wC * ${inputDepth}.0 + d1;\n\n            float xValue =\n                getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n            // Read w(wR, wC, d1, d2).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      if (${hasBias}) {\n        dotProd += getBiasValue(biases, d2);\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderGetBiasValueSource(outputDepth: number):\n    string {\n  return `\n    float getBiasValue(in sampler2D bias, float biasC) {\n      const vec2 biasShapeCR = vec2(${outputDepth}, 1);\n      vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0);\n      vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n      return texture2D(bias, biasUV).r;\n    }`;\n}\n\nexport function getFragmentShaderSource(\n    aShapeRowColDepth: [number, number, number], resultDepth: number,\n    fieldSize: number, stride: number, zeroPad: number,\n    hasBias: boolean): string {\n  const aShapeRC: [number, number] =\n      conv_util.computeTexShapeFrom3D(aShapeRowColDepth);\n\n  const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape(\n      aShapeRowColDepth[2], resultDepth, fieldSize);\n\n  const prologue = getFragmentShaderPrologueSource();\n  const getMatrixValueOrZeroPad =\n      getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const convolve = getFragmentShaderConvolveSource(\n      aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias);\n  const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth);\n\n  return [\n    prologue,\n    getMatrixValueOrZeroPad,\n    getBiasValue,\n    convolve,\n  ].join('\\n');\n}\n\nexport function convolve(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'x', 0);\n  gpgpu.setInputMatrixTexture(weights, 'weights', 1);\n  if (biases != null) {\n    gpgpu.setInputMatrixTexture(biases, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  return `\n    precision highp float;\n    uniform sampler2D source;\n    uniform vec2 sourceStartCR;\n    uniform vec2 destStartCR;\n\n    const vec2 sourceShapeCR =\n      vec2(${sourceShapeRowCol[1]}, ${sourceShapeRowCol[0]});\n    const vec2 sourceSizeCR =\n      vec2(${sourceSizeRowCol[1]}, ${sourceSizeRowCol[0]});\n    const vec2 destSizeCR =\n      vec2(${destSizeRowCol[1]}, ${destSizeRowCol[0]});\n\n    void main() {\n      vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n      float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n      vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n        floor(destOffsetFlat / sourceSizeCR.x));\n      vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n      vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n      gl_FragColor = texture2D(source, sourceUV);\n    }`;\n}\n\nexport function copy(\n    gpgpu: GPGPUContext, program: WebGLProgram, source: WebGLTexture,\n    sourceShapeRowCol: [number, number], sourceStartRowCol: [number, number],\n    sourceSizeRowCol: [number, number], dest: WebGLTexture,\n    destShapeRowCol: [number, number], destStartRowCol: [number, number],\n    destSizeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]);\n  gpgpu.setOutputMatrixWriteRegion(\n      destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1],\n      destSizeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(source, 'source', 0);\n  const sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR');\n  gpgpu.gl.uniform2f(\n      sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]);\n  const destStartCRLoc = gpgpu.getUniformLocation('destStartCR');\n  gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getExpUnaryOp(): string {\n  return 'gl_FragColor = vec4(exp(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp());\n}\n\nexport function exp(\n    gpgpu: GPGPUContext, expProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result);\n}\n\nexport function uploadExpDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from './gpgpu_util';\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nimport {WebGLLoseContextExtension} from './webgl_util';\n\nexport class GPGPUContext {\n  gl: WebGLRenderingContext;\n  textureFloatExtension: {};\n  colorBufferFloatExtension: {};\n  loseContextExtension: WebGLLoseContextExtension;\n  vertexBuffer: WebGLBuffer;\n  indexBuffer: WebGLBuffer;\n  framebuffer: WebGLFramebuffer;\n  outputTexture: WebGLTexture|null = null;\n  program: WebGLProgram|null = null;\n  private disposed = false;\n  private autoDebugValidate = false;\n\n  constructor(gl?: WebGLRenderingContext) {\n    if (gl != null) {\n      this.gl = gl;\n    } else {\n      this.gl = gpgpu_util.createWebGLContext();\n    }\n\n    // WebGL 2.0 enables texture floats without an extension.\n    if (!webgl_util.isWebGL2Enabled()) {\n      this.textureFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float');\n    } else {\n      this.colorBufferFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float');\n    }\n\n    this.loseContextExtension =\n        webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as\n        WebGLLoseContextExtension;\n    this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl);\n    this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl);\n    this.framebuffer = webgl_util.createFramebuffer(this.gl);\n  }\n\n  public dispose() {\n    this.throwIfDisposed();\n    if (this.program != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound WebGLProgram.' +\n          ' This is probably a resource leak, delete the program with ' +\n          'GPGPUContext.deleteProgram before disposing.');\n    }\n    if (this.outputTexture != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound output matrix ' +\n          'texture.  This is probably a resource leak, delete the output ' +\n          'matrix texture with GPGPUContext.deleteMatrixTexture before ' +\n          'disposing.');\n    }\n    const gl = this.gl;\n    webgl_util.callAndCheck(gl, () => gl.finish());\n    webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer));\n    webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer));\n    webgl_util.callAndCheck(\n        gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer));\n    this.loseContextExtension.loseContext();\n    this.disposed = true;\n  }\n\n  public enableAutomaticDebugValidation(enabled: boolean) {\n    this.autoDebugValidate = enabled;\n    webgl_util.enableDebugWebGLErrorChecking(enabled);\n  }\n\n  public createMatrixTexture(rows: number, columns: number): WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createMatrixTexture(this.gl, rows, columns);\n  }\n\n  public uploadPixelDataToTexture(\n      texture: WebGLTexture,\n      pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n    this.throwIfDisposed();\n    gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels);\n  }\n\n  public createPackedMatrixTexture(rows: number, columns: number):\n      WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns);\n  }\n\n  public deleteMatrixTexture(texture: WebGLTexture) {\n    this.throwIfDisposed();\n    if (this.outputTexture === texture) {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n      this.outputTexture = null;\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture));\n  }\n\n  public uploadMatrixToTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    const numChannels = 1;\n    return gpgpu_util.uploadMatrixToTexture(\n        this.gl, texture, rows, columns, matrix, numChannels);\n  }\n\n  public uploadMatrixToPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    return gpgpu_util.uploadMatrixToPackedTexture(\n        this.gl, texture, rows, columns, matrix);\n  }\n\n  public downloadMatrixFromTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () =>\n            gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns));\n  }\n\n  public downloadMatrixFromPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () => gpgpu_util.downloadMatrixFromPackedOutputTexture(\n            this.gl, rows, columns));\n  }\n\n  public createProgram(fragmentShaderSource: string): WebGLProgram {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    const fragmentShader: WebGLShader =\n        webgl_util.createFragmentShader(gl, fragmentShaderSource);\n    const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl);\n    const program: WebGLProgram = webgl_util.createProgram(gl);\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader));\n    webgl_util.linkProgram(gl, program);\n    if (this.autoDebugValidate) {\n      webgl_util.validateProgram(gl, program);\n    }\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader));\n    return program;\n  }\n\n  public deleteProgram(program: WebGLProgram) {\n    this.throwIfDisposed();\n    if (program === this.program) {\n      this.program = null;\n    }\n    if (program != null) {\n      webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program));\n    }\n  }\n\n  public setProgram(program: WebGLProgram|null) {\n    this.throwIfDisposed();\n    this.program = program;\n    if ((this.program != null) && this.autoDebugValidate) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program));\n  }\n\n  public getUniformLocation(uniformName: string): WebGLUniformLocation {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    return webgl_util.getProgramUniformLocationOrThrow(\n        this.gl, this.program!, uniformName);\n  }\n\n  public setInputMatrixTexture(\n      inputMatrixTexture: WebGLTexture, uniformName: string,\n      textureUnit: number) {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    webgl_util.bindTextureToProgramUniformSampler(\n        this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit);\n  }\n\n  public setOutputMatrixTexture(\n      outputMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows);\n  }\n\n  public setOutputPackedMatrixTexture(\n      outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.throwIfDisposed();\n    const [width, height] =\n        tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n    this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height);\n  }\n\n  public setOutputMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    this.setOutputMatrixWriteRegionDriver(\n        startColumn, startRow, numColumns, numRows);\n  }\n\n  public setOutputPackedMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    throw new Error('setOutputPackedMatrixWriteRegion not implemented.');\n  }\n\n  public debugValidate() {\n    if (this.program != null) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.validateFramebuffer(this.gl);\n  }\n\n  public executeProgram() {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    const gl = this.gl;\n    gpgpu_util.bindVertexProgramAttributeStreams(\n        gl, this.program!, this.vertexBuffer);\n    if (this.autoDebugValidate) {\n      this.debugValidate();\n    }\n    webgl_util.callAndCheck(\n        gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0));\n  }\n\n  public blockUntilAllProgramsCompleted() {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(this.gl, () => this.gl.finish());\n  }\n\n  private downloadMatrixDriver(\n      texture: WebGLTexture,\n      downloadAndDecode: () => Float32Array): Float32Array {\n    this.throwIfDisposed();\n    webgl_util.bindColorTextureToFramebuffer(\n        this.gl, texture, this.framebuffer);\n    const result = downloadAndDecode();\n    if (this.outputTexture != null) {\n      webgl_util.bindColorTextureToFramebuffer(\n          this.gl, this.outputTexture, this.framebuffer);\n      if (this.autoDebugValidate) {\n        webgl_util.validateFramebuffer(this.gl);\n      }\n    } else {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n    }\n    return result;\n  }\n\n  private setOutputMatrixTextureDriver(\n      outputMatrixTextureMaybePacked: WebGLTexture, width: number,\n      height: number) {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    webgl_util.bindColorTextureToFramebuffer(\n        gl, outputMatrixTextureMaybePacked, this.framebuffer);\n    if (this.autoDebugValidate) {\n      webgl_util.validateFramebuffer(gl);\n    }\n    this.outputTexture = outputMatrixTextureMaybePacked;\n    webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height));\n    webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height));\n  }\n\n  private setOutputMatrixWriteRegionDriver(\n      x: number, y: number, width: number, height: number) {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(\n        this.gl, () => this.gl.scissor(x, y, width, height));\n  }\n\n  private throwIfDisposed() {\n    if (this.disposed) {\n      throw new Error('Attempted to use disposed GPGPUContext.');\n    }\n  }\n\n  private throwIfNoProgram() {\n    if (this.program == null) {\n      throw new Error('No GPU program is currently set.');\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nexport function getWebGLContextAttributes(): WebGLContextAttributes {\n  return {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: true\n  };\n}\n\nexport function createWebGLContext(canvas?: HTMLCanvasElement) {\n  const attributes = getWebGLContextAttributes();\n  let gl: WebGLRenderingContext;\n  if (canvas != null) {\n    gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes);\n  } else {\n    gl = webgl_util.createWebGLRenderingContext(attributes);\n  }\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE));\n  webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK));\n  return gl;\n}\n\nexport function createVertexShader(gl: WebGLRenderingContext): WebGLShader {\n  const vertexShaderSource = `\n    precision highp float;\n    attribute vec3 clipSpacePos;\n    attribute vec2 uv;\n    varying vec2 resultUV;\n\n    void main() {\n      gl_Position = vec4(clipSpacePos, 1);\n      resultUV = uv;\n    }`;\n  return webgl_util.createVertexShader(gl, vertexShaderSource);\n}\n\nexport function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // [x y z u v] * [upper-left, lower-left, upper-right, lower-right]\n  const vertexArray = new Float32Array(\n      [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]);\n  return webgl_util.createStaticVertexBuffer(gl, vertexArray);\n}\n\nexport function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // OpenGL (and WebGL) have \"CCW == front\" winding\n  const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]);\n  return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices);\n}\n\nfunction getTextureInternalFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled()) {\n    if (numChannels === 4) {\n      // tslint:disable-next-line:no-any\n      return (gl as any).RGBA32F;\n    }\n    // tslint:disable-next-line:no-any\n    return (gl as any).R32F;\n  }\n  return gl.RGBA;\n}\n\nfunction getTextureFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled() && numChannels === 1) {\n    // tslint:disable-next-line:no-any\n    return (gl as any).RED;\n  }\n  return gl.RGBA;\n}\n\nfunction createAndConfigureTexture(\n    gl: WebGLRenderingContext, width: number, height: number,\n    numChannels: number): WebGLTexture {\n  webgl_util.validateTextureSize(gl, width, height);\n  const texture = webgl_util.createTexture(gl);\n\n  const tex2d = gl.TEXTURE_2D;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  const format = getTextureFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n  return texture;\n}\n\nexport function createMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 1;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createColorMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createPackedMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function bindVertexProgramAttributeStreams(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    vertexBuffer: WebGLBuffer) {\n  const posOffset = 0;               // x is the first buffer element\n  const uvOffset = 3 * 4;            // uv comes after [x y z]\n  const stride = (3 * 4) + (2 * 4);  // xyz + uv, each entry is 4-byte float.\n  webgl_util.callAndCheck(\n      gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer));\n  webgl_util.bindVertexBufferToProgramAttribute(\n      gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset);\n  try {\n    webgl_util.bindVertexBufferToProgramAttribute(\n        gl, program, 'uv', vertexBuffer, 2, stride, uvOffset);\n  } catch (e) {\n    // Programs with 1x1 output textures don't use the uv attribute.\n    // This can cause the shader linker to dead-strip it, so we shouldn't\n    // complain or fail if it's not present.\n    if (!e.hasOwnProperty('namedVertexAttributeNotFound')) {\n      throw e;\n    }\n  }\n}\n\nexport function uploadPixelDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n  const numChannels = 4;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nfunction uploadDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, width: number,\n    height: number, data: Float32Array, numChannels: number) {\n  const textureFormat = getTextureFormat(gl, numChannels);\n\n  webgl_util.validateTextureSize(gl, width, height);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texSubImage2D(\n          gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT,\n          data));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function uploadMatrixToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array, numChannels: number) {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture =\n      numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n\n  uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels);\n}\n\nexport function uploadMatrixToPackedTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array) {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA);\n  const numChannels = 4;\n  uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels);\n}\n\nexport function downloadMatrixFromOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture = 4;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          rows * columns, channelsPerTexture));\n  const textureFormat = getTextureFormat(gl, channelsPerTexture);\n\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray));\n\n  const matrix = new Float32Array(rows * columns);\n  tex_util.decodeMatrixFromUnpackedArray(\n      unpackedArray, matrix, channelsPerTexture);\n  return matrix;\n}\n\nexport function downloadMatrixFromPackedOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA));\n  const matrix = new Float32Array(rows * columns);\n  return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getLogUnaryOp(): string {\n  return 'gl_FragColor = vec4(log(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp());\n}\n\nexport function log(\n    gpgpu: GPGPUContext, logProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result);\n}\n\nexport function uploadLogDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          aMax = max(aMax, aCur);\n        }\n      }\n\n      float expSum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          expSum += exp(aCur - aMax);\n        }\n      }\n\n      gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n    }`;\n}\n\nexport function logSumExp(\n    gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(logSumExpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadLogSumExpDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result[0];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderMaxPoolBackprop(\n    dyShapeRCD: [number, number, number], fSize: number, origStride: number,\n    origPad: number) {\n  const origInputDepth = dyShapeRCD[2];\n  const pad = fSize - 1 - origPad;\n  const [dyRows, dyCols, depth] = dyShapeRCD;\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n    uniform sampler2D maxPos;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n      float dxR = dxTexCR.y;\n      float dxC = floor(dxTexCR.x / ${origInputDepth}.0);\n      float d = mod(dxTexCR.x, ${origInputDepth}.0);\n\n      vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0);\n      float dyRCorner = dyRCCorner.x;\n      float dyCCorner = dyRCCorner.y;\n\n      // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float dyR = (dyRCorner + wR) / ${origStride}.0;\n        // TODO(nsthorat): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) {\n          continue;\n        }\n\n        float dyTexR = dyR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float dyC = (dyCCorner + wC) / ${origStride}.0;\n          if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) {\n            continue;\n          }\n\n          float dyTexC = dyC * ${depth}.0 + d;\n\n          // Read dy(dyR, dyC, d).\n          vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read maxPos(dyR, dyC, d).\n          float maxPosValue =\n              ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r;\n\n          // Get the current value, check it against the value from the\n          // position matrix.\n          float curPosValue = wR * ${fSize}.0 + wC;\n          float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n          dotProd += dyValue * mask;\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function maxPoolBackprop(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    maxPositionsTex: WebGLTexture, resultTex: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMaxPoolPositionsSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, true);\n}\n\nexport function getFragmentShaderMaxPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, false);\n}\n\nfunction getFragmentShaderMaxPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, computeMaxPositions: boolean) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions);\n}\n\nexport function maxPoolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMinPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'min', false);\n}\n\nexport function minPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 outputColumnRow;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      float value = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / aDimCR;\n          float candidate = texture2D(matrixA, uv).r;\n          if (isNaN(candidate)) {\n            gl_FragColor = vec4(candidate, 0, 0, 0);\n            return;\n          }\n          value = ${compOp}(value, candidate);\n        }\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'min');\n}\n\nexport function getMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'max');\n}\n\nexport function minMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\nimport {Array2D} from '../ndarray';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as shader_compiler from './shader_compiler';\n\nexport function getFragmentShader(\n    a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  const sharedDim =\n      (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]);\n  const aSnippet =\n      (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow';\n  const bSnippet =\n      (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i';\n\n  const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}];\n  const userCode = `\n    const float sharedDim = ${sharedDim}.0;\n\n    float dotARowBCol(float aRow, float bCol) {\n      float result = 0.0;\n      for (float i = 0.0; i < sharedDim; i += 1.0) {\n        float a = getMatrixA(${aSnippet});\n        float b = getMatrixB(${bSnippet});\n        result += (a * b);\n      }\n      return result;\n    }\n\n    void main() {\n      vec2 resRC = getOutputCoords();\n      setOutput(dotARowBCol(resRC.x, resRC.y));\n    }\n  `;\n  return shader_compiler.makeShader(inputs, out, userCode);\n}\n\nexport function multiplyMatrix(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getNegUnaryOp(): string {\n  return 'gl_FragColor = vec4(-value, 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp());\n}\n\nexport function neg(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, rows: number,\n    columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result);\n}\n\nexport function uploadNegDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) {\n  if (poolType === 'avg' && computePositions) {\n    throw new Error('Cannot compute positions for average pool.');\n  }\n\n  const depth = xShapeRCD[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n\n  let returnValue = 'minMaxValue';\n  if (computePositions) {\n    returnValue = 'minMaxPosition';\n  } else if (poolType === 'avg') {\n    returnValue = 'avgValue';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    varying vec2 resultUV;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${depth}.0);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // max/min x(?, ?, d) to get y(yR, yC, d).\n      // ? = to be determined\n      float minMaxValue = 0.0;\n      float minMaxValueFound = 0.0;\n      float minMaxPosition = 0.0;\n      float avgValue = 0.0;\n\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n          float xTexC = xC * ${depth}.0 + d;\n\n          vec2 texCR = vec2(xTexC, xTexR);\n\n          // Check if the requested UV is invalid.\n          vec2 uv = (texCR + halfCR) / xShapeCR;\n          bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n          bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n          bool outside = lessThanZero || greaterThanOne;\n          if (outside) {\n            continue;\n          }\n\n          float value = texture2D(x, uv).r;\n          if (isNaN(value)) {\n            gl_FragColor = vec4(value, 0, 0, 0);\n            return;\n          }\n          if (${poolType === 'avg'}) {\n            avgValue += value / ${fSize * fSize}.0;\n          } else {\n            // If a min / max value has already been found, use it. If not, use\n            // the current value.\n            float currentMinMaxValue = mix(\n                value, minMaxValue, minMaxValueFound);\n            if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) {\n              minMaxValue = value;\n              minMaxValueFound = 1.0;\n              if (${computePositions}) {\n                minMaxPosition = wR * ${fSize}.0 + wC;\n              }\n            }\n          }\n        }\n      }\n      gl_FragColor = vec4(${returnValue}, 0, 0, 0);\n    }`;\n}\n\nexport function poolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float sum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          sum += texture2D(matrixA, uv).r;\n        }\n      }\n      gl_FragColor = vec4(sum, 0, 0, 0);\n    }`;\n}\n\nexport function reduceSum(\n    gpgpu: GPGPUContext, reduceSumProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(reduceSumProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadReduceSumDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0];\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getReluUnaryOp(): string {\n  return `\n    float result = (value < 0.0 ? 0.0 : value);\n    gl_FragColor = vec4(result, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp());\n}\n\nexport function relu(\n    gpgpu: GPGPUContext, reluProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result);\n}\n\nexport function uploadReluDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nimport * as webgl_util from './webgl_util';\n\nexport function getRenderRGBShader(\n    gpgpu: GPGPUContext, destinationWidth: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    const float destinationWidth = ${destinationWidth}.0;\n    const float a = 1.0;\n\n    void main() {\n      float xr = floor(resultUV.s * destinationWidth) * 3.0;\n      vec3 x = xr + vec3(0, 1, 2);\n\n      float sourceWidth = destinationWidth * 3.0;\n      vec3 u = (x + 0.5) / sourceWidth;\n      float v = 1.0 - resultUV.t;\n\n      float r = texture2D(source, vec2(u[0], v)).r;\n      float g = texture2D(source, vec2(u[1], v)).r;\n      float b = texture2D(source, vec2(u[2], v)).r;\n\n      gl_FragColor = vec4(r, g, b, a);\n    }`;\n\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function renderToCanvas(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  renderToFramebuffer(gpgpu, renderShader, sourceTex);\n}\n\nexport function renderToFramebuffer(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  gpgpu.setProgram(renderShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform vec2 inputDimCR;\n    uniform vec2 resultDimCR;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 resultCR = floor(resultUV * resultDimCR);\n      // indexInFlat = row * stride + column, where stride == numOutputColumns\n      float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n      vec2 inputCR = vec2(\n        mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n        floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n      ) + halfCR;\n\n      vec2 inputUV = inputCR / inputDimCR;\n      gl_FragColor = texture2D(matrixA, inputUV);\n    }`;\n}\n\nexport function reshape(\n    gpgpu: GPGPUContext, reshapeProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture,\n    resultNumRows: number, resultNumCols: number) {\n  const inputSize = aNumRows * aNumCols;\n  const outputSize = resultNumCols * resultNumRows;\n  util.assert(\n      inputSize === outputSize,\n      `The input size (${inputSize}) and output size (${outputSize}) ` +\n          `must match`);\n\n  gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols);\n  gpgpu.setProgram(reshapeProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n\n  const inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR');\n  gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows);\n\n  const resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR');\n  gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows);\n\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as webgl_util from './webgl_util';\n\nexport function getFragmentShaderSource(\n    inputShapeRCD: [number, number, number],\n    outputDimensionsRowCol: [number, number], alignCorners: boolean): string {\n  const depth = inputShapeRCD[2];\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n\n  const effectiveInputShapeRCD = alignCorners ?\n      [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] :\n      inputShapeRCD;\n\n  const effectiveOutputShapeRCD = alignCorners ?\n      [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] :\n      [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth];\n\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    const vec2 inputShapeCR = vec2(${inputShapeRCD[1]}, ${inputShapeRCD[0]});\n    const vec2 inputShapeTexCR = vec2(\n        ${inputTexShapeRC[1]}, ${inputTexShapeRC[0]});\n\n    const vec2 effectiveInputOverOutputRatioCR = vec2(\n        ${effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1]},\n        ${effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0]});\n\n    float sampleInput(float col, float row, float d) {\n      vec2 uv = (vec2(col * ${depth}.0 + d, row) + halfCR) / inputShapeTexCR;\n      return texture2D(matrixA, uv).r;\n    }\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n      vec2 yCR = vec2(floor(yTexCR.x / ${depth}.0), yTexCR.y);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      // Fractional source index.\n      vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n      // Compute the four integer indices.\n      vec2 sourceFloorCR = floor(sourceFracIndexCR);\n      vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n      float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n      float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n      float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n      float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n      vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n      float top = topLeft + (topRight - topLeft) * fracCR[0];\n      float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n      float newValue = top + (bottom - top) * fracCR[1];\n\n      gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function resizeBilinear(\n    gpgpu: GPGPUContext, resizeBilinearProgram: WebGLProgram, a: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(resizeBilinearProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {NDArray} from '../ndarray';\n\nexport type Input = {\n  name: string; array: NDArray;\n};\n\nexport function makeShaderKey(inputs: NDArray[], output: NDArray): string {\n  const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC());\n  return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC();\n}\n\nexport function makeShader(\n    inputs: Input[], output: NDArray, userCode: string): string {\n  const inputPrefixSnippet =\n      inputs.map(x => `uniform sampler2D ${x.name};`).join('\\n');\n  const inputSamplingSnippet =\n      inputs.map(x => getInputSamplingSnippet(x)).join('\\n');\n  const outTexShape = output.getTextureShapeRC();\n  const outputSamplingSnippet =\n      getOutputSamplingSnippet(output.shape, outTexShape);\n  const source = [\n    SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet,\n    outputSamplingSnippet, userCode\n  ].join('\\n');\n  return source;\n}\n\nfunction getInputSamplingSnippet(input: Input) {\n  const arr = input.array;\n  const shape = arr.shape;\n  const texShape = arr.getTextureShapeRC(shape as [number, number]);\n  switch (shape.length) {\n    case 2:\n      return getSampler2D(input.name, shape as [number, number], texShape);\n    default:\n      throw new Error(`${arr.rank}-D input sampling is not yet supported`);\n  }\n}\n\nfunction getOutputSamplingSnippet(\n    outShape: number[], outTexShape: [number, number]): string {\n  switch (outShape.length) {\n    case 2:\n      return getOutput2DCoords(outShape as [number, number], outTexShape);\n    default:\n      throw new Error(\n          `${outShape.length}-D output sampling is not yet supported`);\n  }\n}\n\nconst SHADER_PREFIX = `\n  precision highp float;\n  varying vec2 resultUV;\n  const vec2 halfCR = vec2(0.5, 0.5);\n\n  void setOutput(float val) {\n    gl_FragColor = vec4(val, 0, 0, 0);\n  }\n`;\n\nconst SAMPLE_2D_SNIPPET = `\n  float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n      float row, float col) {\n    float index = dot(vec2(row, col), vec2(numC, 1.0));\n    float texR = floor(index / texNumC);\n    float texC = mod(index, texNumC);\n    vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n    return texture2D(texture, uv).r;\n  }\n`;\n\nfunction getOutput2DCoords(\n    shape: [number, number], texShape: [number, number]) {\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      vec2 getOutputCoords() {\n        return floor(gl_FragCoord.yx);\n      }\n    `;\n  }\n  return `\n    vec2 getOutputCoords() {\n      vec2 resTexRC = floor(gl_FragCoord.yx);\n      float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0));\n      float r = floor(index / ${shape[1]}.0);\n      float c = mod(index, ${shape[1]}.0);\n      return vec2(r, c);\n    }\n  `;\n}\n\nfunction getSampler2D(\n    texName: string, shape: [number, number], texShape: [number, number]) {\n  const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1);\n  const tR = texShape[0];\n  const tC = texShape[1];\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      float ${funcName}(float row, float col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0);\n        return texture2D(${texName}, uv).r;\n      }\n    `;\n  }\n  return `\n    float ${funcName}(float row, float col) {\n      return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col);\n    }\n  `;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getSigmoidUnaryOp(): string {\n  return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);';\n}\n\nexport function getSigmoidFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp());\n}\n\nexport function sigmoid(\n    gpgpu: GPGPUContext, sigmoidProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result);\n}\n\nexport function uploadSigmoidDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(\n      a, rows, columns, getSigmoidUnaryOp());\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getStepUnaryOp(): string {\n  return `\n    float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n    gl_FragColor = vec4(res, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp());\n}\n\nexport function step(\n    gpgpu: GPGPUContext, stepProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result);\n}\n\nexport function uploadStepDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getUnpackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns, rows];\n}\n\nexport function getUnpackedArraySizeFromMatrixSize(\n    matrixSize: number, channelsPerTexture: number): number {\n  return matrixSize * channelsPerTexture;\n}\n\nexport function getColorMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns * 4, rows];\n}\n\nexport function getMatrixSizeFromUnpackedArraySize(\n    unpackedSize: number, channelsPerTexture: number): number {\n  if (unpackedSize % channelsPerTexture !== 0) {\n    throw new Error(\n        'unpackedSize (' + unpackedSize + ') must be a multiple of ' +\n        channelsPerTexture);\n  }\n  return unpackedSize / channelsPerTexture;\n}\n\nexport function encodeMatrixToUnpackedArray(\n    matrix: Float32Array, unpackedArray: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize =\n      getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);\n  if (unpackedArray.length < requiredSize) {\n    throw new Error(\n        'unpackedArray length (' + unpackedArray.length +\n        ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < matrix.length; ++src) {\n    unpackedArray[dst] = matrix[src];\n    dst += channelsPerTexture;\n  }\n}\n\nexport function decodeMatrixFromUnpackedArray(\n    unpackedArray: Float32Array, matrix: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize = getMatrixSizeFromUnpackedArraySize(\n      unpackedArray.length, channelsPerTexture);\n  if (matrix.length < requiredSize) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) {\n    matrix[dst++] = unpackedArray[src];\n  }\n}\n\nexport function getPackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [Math.ceil(columns / 2), Math.ceil(rows / 2)];\n}\n\nexport function getPackedRGBAArraySizeFromMatrixShape(\n    rows: number, columns: number): number {\n  const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  return w * h * 4;\n}\n\nexport function encodeMatrixToPackedRGBA(\n    matrix: Float32Array, rows: number, columns: number,\n    packedRGBA: Float32Array) {\n  const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);\n  if (packedRGBA.length < requiredSize) {\n    throw new Error(\n        'packedRGBA length (' + packedRGBA.length +\n        ') must be >= ' + requiredSize);\n  }\n  /*\n    Unpacked matrix, row-major order in Float32Array[16]:  A B C D\n                                                           E F G H\n                                                           I J K L\n                                                           M N O P\n\n    Packed matrix, 2x2 RGBA32 texture (memory view):       ABEF CDGH IJMN KLOP\n\n    Packed matrix, 2x2 RGBA32 texture (matrix view):       AB|CD\n                                                           EF|GH\n                                                           --+--\n                                                           IJ|KL\n                                                           MN|OP\n   */\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n\n  // loop over full 2x2 blocks\n  {\n    const dstStride = (oddWidth ? 4 : 0);\n    const oneRow = columns;\n    let dst = 0;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      const matrixSrcRow = (blockY * 2 * columns);\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        const matrixSrcCol = blockX * 2;\n        const src = matrixSrcRow + matrixSrcCol;\n        packedRGBA[dst] = matrix[src];\n        packedRGBA[dst + 1] = matrix[src + 1];\n        packedRGBA[dst + 2] = matrix[src + oneRow];\n        packedRGBA[dst + 3] = matrix[src + oneRow + 1];\n        dst += 4;\n      }\n      dst += dstStride;\n    }\n  }\n\n  // loop down final odd column\n  if (oddWidth) {\n    let src = columns - 1;\n    let dst = (textureWidth - 1) * 4;\n    const srcStride = 2 * columns;\n    const dstStride = textureWidth * 4;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      packedRGBA[dst] = matrix[src];\n      packedRGBA[dst + 2] = matrix[src + columns];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (rows - 1) * columns;\n    let dst = (textureHeight - 1) * textureWidth * 4;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      packedRGBA[dst++] = matrix[src++];\n      packedRGBA[dst++] = matrix[src++];\n      dst += 2;\n    }\n  }\n\n  // fill in bottom-right texel\n  if (oddWidth && oddHeight) {\n    packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];\n  }\n\n  return packedRGBA;\n}\n\nexport function decodeMatrixFromPackedRGBA(\n    packedRGBA: Float32Array, rows: number, columns: number,\n    matrix: Float32Array): Float32Array {\n  const requiredSize = rows * columns;\n  if (requiredSize < matrix.length) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  // loop over full 2x2 blocks\n  {\n    const srcStride = oddWidth ? 4 : 0;\n    const dstStride = columns + (oddWidth ? 1 : 0);\n    let src = 0;\n    let dstRow1 = 0;\n    let dstRow2 = columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n      }\n      src += srcStride;\n      dstRow1 += dstStride;\n      dstRow2 += dstStride;\n    }\n  }\n\n  // loop down final column\n  if (oddWidth) {\n    let src = (textureWidth - 1) * 4;\n    let dst = columns - 1;\n    const srcStride = textureWidth * 4;\n    const dstStride = 2 * columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      matrix[dst] = packedRGBA[src];\n      matrix[dst + columns] = packedRGBA[src + 2];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (textureHeight - 1) * textureWidth * 4;\n    let dst = (rows - 1) * columns;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      matrix[dst++] = packedRGBA[src++];\n      matrix[dst++] = packedRGBA[src++];\n      src += 2;\n    }\n  }\n\n  // fill in bottom-right cell\n  if (oddWidth && oddHeight) {\n    matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];\n  }\n\n  return matrix;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport class TextureManager {\n  private numUsedTextures = 0;\n  private numFreeTextures = 0;\n  private freeTextures: {[shape: string]: WebGLTexture[]} = {};\n  private logEnabled = false;\n  private usedTextureCount: {[shape: string]: number} = {};\n\n  constructor(private gpgpu: GPGPUContext) {}\n\n  acquireTexture(shapeRC: [number, number]): WebGLTexture {\n    const shapeKey = getKeyFromTextureShape(shapeRC);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    if (!(shapeKey in this.usedTextureCount)) {\n      this.usedTextureCount[shapeKey] = 0;\n    }\n    this.usedTextureCount[shapeKey]++;\n\n    if (this.freeTextures[shapeKey].length > 0) {\n      this.numFreeTextures--;\n      this.numUsedTextures++;\n      this.log();\n      return this.freeTextures[shapeKey].shift()!;\n    }\n    this.numUsedTextures++;\n    this.log();\n\n    return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]);\n  }\n\n  releaseTexture(texture: WebGLTexture, shape: [number, number]): void {\n    const shapeKey = getKeyFromTextureShape(shape);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    this.freeTextures[shapeKey].push(texture);\n    this.numFreeTextures++;\n    this.numUsedTextures--;\n    this.usedTextureCount[shapeKey]--;\n    this.log();\n  }\n\n  private log() {\n    if (!this.logEnabled) {\n      return;\n    }\n    const total = this.numFreeTextures + this.numUsedTextures;\n    console.log(\n        'Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures,\n        `(${total})`);\n  }\n\n  getNumUsedTextures(): number {\n    return this.numUsedTextures;\n  }\n\n  getNumFreeTextures(): number {\n    return this.numFreeTextures;\n  }\n\n  dispose() {\n    for (const shape in this.freeTextures) {\n      if (this.freeTextures.hasOwnProperty(shape)) {\n        for (let i = 0; i < this.freeTextures[shape].length; i++) {\n          this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]);\n        }\n      }\n    }\n  }\n}\n\nfunction getKeyFromTextureShape(shapeRowsCol: [number, number]): string {\n  return shapeRowsCol[0] + '_' + shapeRowsCol[1];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\n/**\n * Sine\n */\nfunction getSinUnaryOp(): string {\n  return `\n    gl_FragColor = vec4(sin(value), 0, 0, 0);\n  `;\n}\n\nexport function getSinFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp());\n}\n\nexport function sin(\n    gpgpu: GPGPUContext, sinProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result);\n}\n\nexport function uploadSinDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp());\n}\n\n/**\n * Tanh\n */\nfunction getTanhUnaryOp(): string {\n  return `\n    float e2x = exp(-2.0 * value);\n    gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n  `;\n}\n\nexport function getTanhFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp());\n}\n\nexport function tanh(\n    gpgpu: GPGPUContext, tanhProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result);\n}\n\nexport function uploadTanhDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(resultOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    void main() {\n      float value = texture2D(matrixA, resultUV).r;\n      ${resultOp}\n    }`;\n}\n\nexport function unaryOp(\n    gpgpu: GPGPUContext, unaryOpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(unaryOpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadUnaryOpDownload(\n    a: Float32Array, rows: number, columns: number,\n    resultOp: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const fragmentShaderSrc = getFragmentShaderSource(resultOp);\n  const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSrc);\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nlet USE_WEBGL2_WHEN_AVAILABLE = false;\nlet WEBGL2_ENABLED: boolean|undefined = null!;\nlet MAX_TEXTURE_SIZE: number = null!;\n\nimport * as util from '../../util';\n\nexport interface WebGLContextAttributes {\n  alpha?: boolean;\n  antialias?: boolean;\n  premultipliedAlpha?: boolean;\n  preserveDrawingBuffer?: boolean;\n  depth?: boolean;\n  stencil?: boolean;\n  failIfMajorPerformanceCaveat?: boolean;\n}\n\n/** @hidden */\nexport const IS_NAN_SHADER_FUNC = `\nbool isNaN(float val) {\n  return val == val ? false : true;\n}\n`;\n\nexport interface WebGLLoseContextExtension { loseContext(): void; }\n\nexport function createWebGLRenderingContext(attributes: WebGLContextAttributes):\n    WebGLRenderingContext {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return createWebGLRenderingContextFromCanvas(canvas, attributes);\n}\n\n/**\n * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL\n * 2.0 is available.\n */\nexport function preferWebGL1() {\n  USE_WEBGL2_WHEN_AVAILABLE = false;\n  WEBGL2_ENABLED = undefined;\n}\n\n/**\n * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration.\n */\nexport function preferWebGL2() {\n  USE_WEBGL2_WHEN_AVAILABLE = true;\n  WEBGL2_ENABLED = undefined;\n}\n\nexport function isWebGL2Enabled() {\n  if (!USE_WEBGL2_WHEN_AVAILABLE) {\n    return false;\n  }\n\n  if (WEBGL2_ENABLED === undefined) {\n    const tempCanvas = document.createElement('canvas');\n    const gl = tempCanvas.getContext('webgl2');\n    if (gl != null) {\n      WEBGL2_ENABLED = true;\n\n      const loseContextExtension =\n          getExtensionOrThrow(\n              gl as WebGLRenderingContext, 'WEBGL_lose_context') as\n          WebGLLoseContextExtension;\n      loseContextExtension.loseContext();\n    } else {\n      WEBGL2_ENABLED = false;\n    }\n  }\n  return WEBGL2_ENABLED;\n}\n\nexport function createWebGLRenderingContextFromCanvas(\n    canvas: HTMLCanvasElement,\n    attributes: WebGLContextAttributes): WebGLRenderingContext {\n  let gl: WebGLRenderingContext;\n  if (isWebGL2Enabled()) {\n    gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext;\n  } else {\n    gl = (canvas.getContext('webgl', attributes) ||\n          canvas.getContext('experimental-webgl', attributes)) as\n        WebGLRenderingContext;\n  }\n\n  if (gl == null) {\n    throw new Error('This browser does not support WebGL.');\n  }\n  return gl;\n}\n\nexport function callAndCheck<T>(gl: WebGLRenderingContext, func: () => T): T {\n  const returnValue = func();\n  checkWebGLError(gl);\n  return returnValue;\n}\n\nlet webGLDebugErrorCheckingEnabled = false;\n\nexport function enableDebugWebGLErrorChecking(enabled: boolean) {\n  webGLDebugErrorCheckingEnabled = enabled;\n}\n\nexport function checkWebGLError(gl: WebGLRenderingContext) {\n  if (webGLDebugErrorCheckingEnabled) {\n    const error = gl.getError();\n    if (error !== gl.NO_ERROR) {\n      throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error));\n    }\n  }\n}\n\nexport function getWebGLErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.NO_ERROR:\n      return 'NO_ERROR';\n    case gl.INVALID_ENUM:\n      return 'INVALID_ENUM';\n    case gl.INVALID_VALUE:\n      return 'INVALID_VALUE';\n    case gl.INVALID_OPERATION:\n      return 'INVALID_OPERATION';\n    case gl.INVALID_FRAMEBUFFER_OPERATION:\n      return 'INVALID_FRAMEBUFFER_OPERATION';\n    case gl.OUT_OF_MEMORY:\n      return 'OUT_OF_MEMORY';\n    case gl.CONTEXT_LOST_WEBGL:\n      return 'CONTEXT_LOST_WEBGL';\n    default:\n      return 'Unknown error code ' + status;\n  }\n}\n\nexport function getExtensionOrThrow(\n    gl: WebGLRenderingContext, extensionName: string): {} {\n  return throwIfNull<{}>(\n      gl, () => gl.getExtension(extensionName),\n      'Extension \"' + extensionName + '\" not supported on this browser.');\n}\n\nexport function createVertexShader(\n    gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader {\n  const vertexShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.VERTEX_SHADER),\n      'Unable to create vertex WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource));\n  callAndCheck(gl, () => gl.compileShader(vertexShader));\n  if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(vertexShader));\n    throw new Error('Failed to compile vertex shader.');\n  }\n  return vertexShader;\n}\n\nexport function createFragmentShader(\n    gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader {\n  const fragmentShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.FRAGMENT_SHADER),\n      'Unable to create fragment WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource));\n  callAndCheck(gl, () => gl.compileShader(fragmentShader));\n  if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(fragmentShader));\n    throw new Error('Failed to compile fragment shader.');\n  }\n  return fragmentShader;\n}\n\nexport function createProgram(gl: WebGLRenderingContext): WebGLProgram {\n  return throwIfNull<WebGLProgram>(\n      gl, () => gl.createProgram(), 'Unable to create WebGLProgram.');\n}\n\nexport function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.linkProgram(program));\n  if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Failed to link vertex and fragment shaders.');\n  }\n}\n\nexport function validateProgram(\n    gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.validateProgram(program));\n  if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Shader program validation failed.');\n  }\n}\n\nexport function createStaticVertexBuffer(\n    gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function createStaticIndexBuffer(\n    gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function queryMaxTextureSize(gl: WebGLRenderingContext): number {\n  if (MAX_TEXTURE_SIZE != null) {\n    return MAX_TEXTURE_SIZE;\n  }\n  MAX_TEXTURE_SIZE =\n      callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE));\n  return MAX_TEXTURE_SIZE;\n}\n\nexport function getChannelsPerTexture(): number {\n  if (isWebGL2Enabled()) {\n    return 1;\n  }\n  return 4;\n}\n\nexport function createTexture(gl: WebGLRenderingContext): WebGLTexture {\n  return throwIfNull<WebGLTexture>(\n      gl, () => gl.createTexture(), 'Unable to create WebGLTexture.');\n}\n\nexport function validateTextureSize(\n    gl: WebGLRenderingContext, width: number, height: number) {\n  const maxTextureSize: number = queryMaxTextureSize(gl);\n  if ((width <= 0) || (height <= 0)) {\n    const requested = '[' + width + 'x' + height + ']';\n    throw new Error('Requested texture size ' + requested + ' is invalid.');\n  }\n  if ((width > maxTextureSize) || (height > maxTextureSize)) {\n    const requested = '[' + width + 'x' + height + ']';\n    const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']';\n    throw new Error(\n        'Requested texture size ' + requested +\n        ' greater than WebGL maximum on this browser / GPU ' + max + '.');\n  }\n}\n\nexport function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer {\n  return throwIfNull<WebGLFramebuffer>(\n      gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.');\n}\n\nexport function bindVertexBufferToProgramAttribute(\n    gl: WebGLRenderingContext, program: WebGLProgram, attribute: string,\n    buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number,\n    itemOffsetInBytes: number) {\n  const loc = gl.getAttribLocation(program, attribute);\n  if (loc === -1) {\n    const error = new Error(\n        'Unable to get attribute \"' + attribute + '\" on WebGLProgram.');\n    // tslint:disable-next-line:no-any\n    (error as any).namedVertexAttributeNotFound = attribute;\n    throw error;\n  }\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl,\n      () => gl.vertexAttribPointer(\n          loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes,\n          itemOffsetInBytes));\n  callAndCheck(gl, () => gl.enableVertexAttribArray(loc));\n}\n\nexport function bindTextureUnit(\n    gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n}\n\nexport function unbindTextureUnit(\n    gl: WebGLRenderingContext, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function getProgramUniformLocationOrThrow(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    uniformName: string): WebGLUniformLocation {\n  return throwIfNull<WebGLUniformLocation>(\n      gl, () => gl.getUniformLocation(program, uniformName),\n      'uniform \"' + uniformName + '\" not present in program.');\n}\n\nexport function bindTextureToProgramUniformSampler(\n    gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture,\n    uniformSamplerName: string, textureUnit: number) {\n  callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit));\n  const samplerLocation =\n      getProgramUniformLocationOrThrow(gl, program, uniformSamplerName);\n  callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit));\n}\n\nexport function bindCanvasToFramebuffer(gl: WebGLRenderingContext) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n  callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height));\n  callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height));\n}\n\nexport function bindColorTextureToFramebuffer(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0));\n}\n\nexport function unbindColorTextureFromFramebuffer(\n    gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0));\n}\n\nexport function validateFramebuffer(gl: WebGLRenderingContext) {\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new Error(\n        'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status));\n  }\n}\n\nexport function getFramebufferErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n      return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS';\n    case gl.FRAMEBUFFER_UNSUPPORTED:\n      return 'FRAMEBUFFER_UNSUPPORTED';\n    default:\n      return 'unknown error ' + status;\n  }\n}\n\nfunction throwIfNull<T>(\n    gl: WebGLRenderingContext, returnTOrNull: () => T | null,\n    failureMessage: string): T {\n  const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull());\n  if (tOrNull == null) {\n    throw new Error(failureMessage);\n  }\n  return tOrNull as T;\n}\n\nfunction validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) {\n  const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;\n  const glTextureUnit = textureUnit + gl.TEXTURE0;\n  if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) {\n    const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']';\n    throw new Error('textureUnit must be in ' + textureUnitRange + '.');\n  }\n}\n\nexport function getTextureShapeFromLogicalShape(\n    gl: WebGLRenderingContext, logicalShape: number[],\n    preferredTexShape?: [number, number]): [number, number] {\n  const maxTexSize = queryMaxTextureSize(gl);\n  const size = util.sizeFromShape(logicalShape);\n  if (preferredTexShape != null) {\n    const sizePreferred = util.sizeFromShape(preferredTexShape);\n    util.assert(\n        size === sizePreferred,\n        `Size of shape (${size}) must match size of ` +\n            `preferredShape (${sizePreferred})`);\n    if (preferredTexShape[0] <= maxTexSize &&\n        preferredTexShape[1] <= maxTexSize) {\n      return preferredTexShape;\n    }\n  }\n\n  if (logicalShape.length <= 1 && size <= maxTexSize) {\n    return [size, 1];\n  } else if (\n      logicalShape.length === 2 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] <= maxTexSize) {\n    return logicalShape as [number, number];\n  } else if (\n      logicalShape.length === 3 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] * logicalShape[2] <= maxTexSize) {\n    return [logicalShape[0], logicalShape[1] * logicalShape[2]];\n  } else {\n    return util.sizeToSquarishShape(size);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {AddNode, ArgMaxEqualsNode, ArgMaxNode, Concat3DNode, Convolution2DNode, DivideNode, ExpNode, FusedLinearCombinationNode, Graph, LogNode, MatMulNode, MaxPoolNode, MeanSquaredCostNode, MultiplyNode, Node, ReduceSumNode, ReLUNode, ReshapeNode, SigmoidNode, SoftmaxCrossEntropyCostNode, SoftmaxNode, SplitNode, SquareNode, SubtractNode, TanHNode, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {Add} from './ops/add';\nimport {ArgMax} from './ops/argmax';\nimport {ArgMaxEquals} from './ops/argmaxequals';\nimport {Concat3D} from './ops/concat3d';\nimport {Convolution2D} from './ops/convolution';\nimport {Divide} from './ops/divide';\nimport {ReLU, Sigmoid, Square, TanH} from './ops/element_wise_activation';\nimport {MeanSquaredCost} from './ops/element_wise_cost';\nimport {Exp} from './ops/exp';\nimport {LinearCombination} from './ops/linear_combination';\nimport {Log} from './ops/log';\nimport {MatMul} from './ops/matmul';\nimport {MaxPool} from './ops/max_pool';\nimport {Multiply} from './ops/multiply';\nimport {Operation} from './ops/op';\nimport {ReduceSum} from './ops/reduce_sum';\nimport {Reshape} from './ops/reshape';\nimport {Softmax, SoftmaxCrossEntropyCost} from './ops/softmax';\nimport {Split} from './ops/split';\nimport {Subtract} from './ops/subtract';\n\nexport function emitFromGraphNodes(nodes: Node[]): Operation[] {\n  const ops: Operation[] = [];\n  nodes.forEach(node => Array.prototype.push.apply(ops, emitOpFromNode(node)));\n  return ops;\n}\n\nfunction emitOpFromNode(node: Node): Operation[] {\n  if (node instanceof ReshapeNode) {\n    return [new Reshape(node.inputs[ReshapeNode.X], node.output)];\n  } else if (node instanceof MatMulNode) {\n    const x1 = node.inputs[MatMulNode.X1];\n    const x2 = node.inputs[MatMulNode.X2];\n    return [new MatMul(x1, x2, node.output)];\n  } else if (node instanceof Convolution2DNode) {\n    const w = node.inputs[Convolution2DNode.W];\n    const x = node.inputs[Convolution2DNode.X];\n    const b = node.inputs[Convolution2DNode.B];\n    return [new Convolution2D(\n        w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride,\n        node.zeroPad)];\n  } else if (node instanceof MaxPoolNode) {\n    const x = node.inputs[MaxPoolNode.X];\n    return [new MaxPool(\n        x, node.output, node.fieldSize, node.stride, node.zeroPad)];\n  } else if (node instanceof ExpNode) {\n    return [new Exp(node.inputs[ExpNode.X], node.output)];\n  } else if (node instanceof LogNode) {\n    return [new Log(node.inputs[LogNode.X], node.output)];\n  } else if (node instanceof ReLUNode) {\n    return [new ReLU(node.inputs[ReLUNode.X], node.output)];\n  } else if (node instanceof TanHNode) {\n    return [new TanH(node.inputs[TanHNode.X], node.output)];\n  } else if (node instanceof SigmoidNode) {\n    return [new Sigmoid(node.inputs[SigmoidNode.X], node.output)];\n  } else if (node instanceof SoftmaxCrossEntropyCostNode) {\n    const x = node.inputs[SoftmaxCrossEntropyCostNode.X];\n    const target = node.inputs[SoftmaxCrossEntropyCostNode.TARGET];\n    return [new SoftmaxCrossEntropyCost(x, target, node.output)];\n  } else if (node instanceof SoftmaxNode) {\n    return [new Softmax(node.inputs[SoftmaxNode.X], node.output)];\n  } else if (node instanceof MeanSquaredCostNode) {\n    const label = node.inputs[MeanSquaredCostNode.LABEL];\n    const prediction = node.inputs[MeanSquaredCostNode.PREDICTION];\n    return [new MeanSquaredCost(label, prediction, node.output)];\n  } else if (node instanceof ArgMaxEqualsNode) {\n    return [new ArgMaxEquals(\n        node.inputs[ArgMaxEqualsNode.X1], node.inputs[ArgMaxEqualsNode.X2],\n        node.output)];\n  } else if (node instanceof ArgMaxNode) {\n    return [new ArgMax(node.x, node.output)];\n  } else if (node instanceof FusedLinearCombinationNode) {\n    return [new LinearCombination(\n        node.inputs[FusedLinearCombinationNode.T1],\n        node.inputs[FusedLinearCombinationNode.T2],\n        node.inputs[FusedLinearCombinationNode.C1],\n        node.inputs[FusedLinearCombinationNode.C2], node.output)];\n  } else if (node instanceof Concat3DNode) {\n    return [new Concat3D(\n        node.inputs[Concat3DNode.X1], node.inputs[Concat3DNode.X2], node.axis,\n        node.output)];\n  } else if (node instanceof SquareNode) {\n    return [new Square(node.inputs[SquareNode.X], node.output)];\n  } else if (node instanceof AddNode) {\n    return [new Add(\n        node.inputs[AddNode.T1], node.inputs[AddNode.T2], node.output)];\n  } else if (node instanceof SubtractNode) {\n    return [new Subtract(\n        node.inputs[SubtractNode.T1], node.inputs[SubtractNode.T2],\n        node.output)];\n  } else if (node instanceof MultiplyNode) {\n    return [new Multiply(\n        node.inputs[MultiplyNode.T1], node.inputs[MultiplyNode.T2],\n        node.output)];\n  } else if (node instanceof DivideNode) {\n    return [new Divide(\n        node.inputs[DivideNode.T1], node.inputs[DivideNode.T2], node.output)];\n  } else if (node instanceof SplitNode) {\n    return [new Split(node.inputs[SplitNode.X], node.outputs)];\n  } else if (node instanceof ReduceSumNode) {\n    return [new ReduceSum(node.inputs[ReduceSumNode.X], node.output)];\n  } else if (graph_util.isInputNode(node)) {\n    return [];\n  } else {\n    // tslint:disable-next-line:no-any\n    throw Error('Unsupported node type: ' + (node.constructor as any).name);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Add extends Operation {\n  private dySizeScalar: Scalar;\n\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(x1.shape)) {\n        result = math.scalarPlusArray(x1, x2);\n      } else if (util.isScalarShape(x2.shape)) {\n        result = math.scalarPlusArray(x2, x1);\n      } else {\n        result = math.add(x1, x2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x1Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x1Tensor, dy);\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x2Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x2Tensor, dy);\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMax extends Operation {\n  /**\n   * An ArgMax operation.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMax(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMax backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMaxEquals extends Operation {\n  /**\n   * An ArgMaxEquals operation.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMaxEquals(x1, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMaxEquals backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as concat3d_util from '../math/concat3d_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Concat3D extends Operation {\n  /**\n   * A Concat 3D operation.\n   *\n   * Concats two 3D tensors along an axis.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor, private axis: number,\n      private yTensor: Tensor) {\n    super();\n    concat3d_util.assertConcat3DShapesMatch(\n        x1Tensor.shape, x2Tensor.shape, axis);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor) as Array3D;\n    const x2 = inferenceArrays.get(this.x2Tensor) as Array3D;\n\n    math.scope((keep) => {\n      const concatResult = math.concat3D(x1, x2, this.axis);\n      inferenceArrays.set(this.yTensor, keep(concatResult));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('Concat3D backprop not implemented.');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Convolution2D extends Operation {\n  private zeroPad: number;\n\n  /**\n   * Constructs a convolution op with the specified properties.\n   *\n   * @param inputShape The shape of the input ndarray.\n   * @param fieldSize The size of the filter (rows/cols of sliding window).\n   * @param outputDepth The depth of the output (Number of filters).\n   * @param stride How many pixels to shift the filter by when sliding.\n   *     Defaults to 1.\n   * @param zeroPad How many pixels to pad the input from each side. Defaults to\n   *     a value so that the rows and columns of the output ndarray is\n   *     the same as the input ndarray.\n   * @param weights Optional. The weights of the filters.\n   * @param biases Optional. The bias terms of the filters.\n   */\n  constructor(\n      private wTensor: Tensor, private xTensor: Tensor, private bTensor: Tensor,\n      private yTensor: Tensor, private fieldSize: number,\n      private outputDepth: number, private stride = 1, zeroPad?: number) {\n    super();\n    this.assertWeightsShape(wTensor.shape);\n    this.zeroPad = zeroPad != null ?\n        zeroPad :\n        conv_util.computeDefaultPad(\n            this.xTensor.shape as [number, number, number], this.fieldSize,\n            this.stride);\n    util.assert(\n        util.isInt(this.zeroPad),\n        `The zero padding (${this.zeroPad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const biases = inferenceArrays.get(this.bTensor) as Array1D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.conv2d(x, weights, biases, this.stride, this.zeroPad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      const {dw, db, dx} =\n          math.conv2dBackProp(x, dy, weights, this.stride, this.zeroPad);\n      gradientArrays.set(this.wTensor, keep(dw));\n      gradientArrays.set(this.bTensor, keep(db));\n      gradientArrays.set(this.xTensor, keep(dx));\n    });\n  }\n\n  private assertWeightsShape(weightsShape: number[]) {\n    util.assert(\n        weightsShape[0] === this.fieldSize &&\n            weightsShape[1] === this.fieldSize &&\n            weightsShape[2] === this.xTensor.shape[2] &&\n            weightsShape[3] === this.outputDepth,\n        `weights must be of shape [${this.fieldSize},${this.fieldSize},` +\n            `${this.xTensor.shape[2]},${this.outputDepth}] but they are of` +\n            `shape [${weightsShape}]`);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Divide extends Operation {\n  private ones: NDArray;\n\n  /**\n   * Element-wise divide operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarDividedByArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayDividedByScalar(t1, t2);\n      } else {\n        result = math.divide(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    const x1IsScalar = util.isScalarShape(x1.shape);\n    const x2IsScalar = util.isScalarShape(x2.shape);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (x1IsScalar) {\n          const div = math.divide(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(div)));\n\n          div.dispose();\n        } else if (x2IsScalar) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.divide(dy, x2)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        // dx2 = -1 * x1 * x2 ^ -2.\n        const x2Squared = math.elementWiseMul(x2, x2);\n\n        let x1OverX2Squared: NDArray;\n        if (x2IsScalar) {\n          x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared);\n        } else if (x1IsScalar) {\n          x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared);\n        } else {\n          x1OverX2Squared = math.divide(x1, x2Squared);\n        }\n\n        const dx2 = math.neg(x1OverX2Squared);\n        const dyTimesDerivative = math.elementWiseMul(dy, dx2);\n\n        if (x2IsScalar) {\n          gradientArrays.set(this.x2Tensor, keep(math.sum(dyTimesDerivative)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(dyTimesDerivative));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {ActivationFunction, ReLUFunc, SigmoidFunc, SquareFunc, TanHFunc} from '../math/activation_functions';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseActivation extends Operation {\n  constructor(\n      protected xTensor: Tensor, protected yTensor: Tensor,\n      private func: ActivationFunction) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(this.func.output(math, x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    // dE/dx_i = sum_j dE/dy_j * dy_j/dx_i\n    //         = dE/dy_i * dy_i/dx_i\n    const x = inferenceArrays.get(this.xTensor);\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      const dydx = this.func.der(math, x, y);\n      gradientArrays.set(this.xTensor, keep(math.elementWiseMul(dy, dydx)));\n      dydx.dispose();\n    });\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReLU extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new ReLUFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class TanH extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new TanHFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Sigmoid extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SigmoidFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Square extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SquareFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {ElementWiseCostFunction, SquareCostFunc} from '../math/cost_functions';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseCost<T extends NDArray> extends Operation {\n  private oneOverNScalar: Scalar;\n\n  constructor(\n      protected x1Tensor: Tensor, protected x2Tensor: Tensor,\n      protected yTensor: Tensor, protected func: ElementWiseCostFunction) {\n    super();\n    this.oneOverNScalar = Scalar.new(1 / util.sizeFromShape(x1Tensor.shape));\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      const elementWiseCost = this.func.cost(math, x1, x2);\n      const sum = math.sum(elementWiseCost);\n      const result = math.scalarTimesArray(this.oneOverNScalar, sum);\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(this.func.der(math, x1, x2)));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(this.func.der(math, x2, x1)));\n      }\n    });\n  }\n\n  dispose() {\n    this.func.dispose();\n    this.oneOverNScalar.dispose();\n  }\n}\n\n/**\n * @hidden\n */\nexport class MeanSquaredCost extends ElementWiseCost<Array1D> {\n  constructor(x1Tensor: Tensor, x2Tensor: Tensor, yTensor: Tensor) {\n    super(x1Tensor, x2Tensor, yTensor, new SquareCostFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Exp extends Operation {\n  /**\n   * Exponentation operation - e^x.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.exp(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.elementWiseMul(y, dy)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class LinearCombination extends Operation {\n  /**\n   * A 2-tensor linear combination operation.\n   *\n   * Combines tensors x1 and x2 (of the same shape) with weights c1 & c2;\n   * Computes c1*x1 + c2*x2.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private c1Tensor: Tensor, private c2Tensor: Tensor,\n      private outTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor).asScalar();\n    const c2 = inferenceArrays.get(this.c2Tensor).asScalar();\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor);\n    const c2 = inferenceArrays.get(this.c2Tensor);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(math.scalarTimesArray(c1, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(math.scalarTimesArray(c2, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.c1Tensor)) {\n        const dotProduct1 = math.elementWiseMul(x1, dy);\n        gradientArrays.set(this.c1Tensor, keep(math.sum(dotProduct1)));\n      }\n\n      if (graph_util.shouldBackProp(this.c2Tensor)) {\n        const dotProduct2 = math.elementWiseMul(x2, dy);\n        gradientArrays.set(this.c2Tensor, keep(math.sum(dotProduct2)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Log extends Operation {\n  /**\n   * Natural log operation - ln(x)\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.log(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.divide(dy, x)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MatMul extends Operation {\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (x1.shape.length === 2 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor, keep(math.matMul(x1 as Array2D, x2 as Array2D)));\n      } else if (x1.shape.length === 2 && x2.shape.length === 1) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.matrixTimesVector(x1 as Array2D, x2 as Array1D)));\n      } else if (x1.shape.length === 1 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.vectorTimesMatrix(x1 as Array1D, x2 as Array2D)));\n      }\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    let x1 = inferenceArrays.get(this.x1Tensor);\n    let x2 = inferenceArrays.get(this.x2Tensor);\n    let dy = gradientArrays.get(this.yTensor);\n\n    if (x1.shape.length === 1) {\n      x1 = x1.reshape([1, x1.size]);\n      dy = dy.reshape([1, dy.size]);\n    }\n    if (x2.shape.length === 1) {\n      x2 = x2.reshape([x2.size, 1]);\n      dy = dy.reshape([dy.size, 1]);\n    }\n\n    math.scope((keep) => {\n      // y = x1 * x2\n      // dx1 = dy * x2T\n      // dx2 = x1T * dy\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        const dx1 = math.matMul(\n            dy as Array2D, x2 as Array2D, MatrixOrientation.REGULAR,\n            MatrixOrientation.TRANSPOSED);\n        gradientArrays.set(\n            this.x1Tensor,\n            keep(this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        const dx2 = math.matMul(\n            x1 as Array2D, dy as Array2D, MatrixOrientation.TRANSPOSED,\n            MatrixOrientation.REGULAR);\n        gradientArrays.set(\n            this.x2Tensor,\n            keep(this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array2D, Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MaxPool extends Operation {\n  private pad: number;\n\n  constructor(\n      private xTensor: Tensor, private yTensor: Tensor,\n      private fieldSize: number, private stride = 1, pad?: number) {\n    super();\n\n    if (pad != null) {\n      this.pad = pad;\n    } else {\n      this.pad = conv_util.computeDefaultPad(\n          xTensor.shape as [number, number, number], this.fieldSize,\n          this.stride);\n    }\n\n    util.assert(\n        util.isInt(this.pad),\n        `The zero padding (${this.pad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.maxPool(x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor,\n          keep(math.maxPoolBackprop(\n              dy, x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Multiply extends Operation {\n  /**\n   * Element-wise multiply operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarTimesArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.scalarTimesArray(t2, t1);\n      } else {\n        result = math.elementWiseMul(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x2.shape)) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.scalarTimesArray(x2, dy)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.elementWiseMul(x2, dy)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x1);\n\n          gradientArrays.set(this.x2Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x1.shape)) {\n          gradientArrays.set(\n              this.x2Tensor, keep(math.scalarTimesArray(x1, dy)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(math.elementWiseMul(x1, dy)));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\n/**\n * @hidden\n */\nexport abstract class Operation {\n  abstract feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap):\n      void;\n\n  abstract backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap): void;\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {}\n\n  dispose() {}\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ReduceSum extends Operation {\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(private x: Tensor, private outTensor: Tensor) {\n    super();\n    util.assertShapesMatch(outTensor.shape, []);\n  }\n\n  private ones: NDArray;\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.x);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.outTensor, keep(math.sum(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.x)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      const dy = gradientArrays.get(this.outTensor);\n      if (this.ones == null) {\n        const xArray = inferenceArrays.get(this.x);\n        this.ones = NDArray.zerosLike(xArray);\n        this.ones.fill(1);\n      }\n      gradientArrays.set(this.x, keep(math.scalarTimesArray(dy, this.ones)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Reshape<T1 extends NDArray, T2 extends NDArray> extends Operation {\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n    const xSize = util.sizeFromShape(xTensor.shape);\n    const ySize = util.sizeFromShape(yTensor.shape);\n    util.assert(\n        xSize === ySize,\n        `The input size (${xSize}) and output size (${ySize}) must match`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as T1;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor, keep(math.reshape<T1, T2>(x, this.yTensor.shape)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const dy = gradientArrays.get(this.yTensor) as T2;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor, keep(math.reshape<T2, T1>(dy, this.xTensor.shape)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Softmax extends Operation {\n  constructor(private logitsTensor: Tensor, private output: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    return math.scope((keep) => {\n      inferenceArrays.set(this.output, keep(math.softmax(logits)));\n    });\n  }\n\n  backProp() {\n    throw Error('Softmax backprop is not yet implemented');\n  }\n}\n\nexport class SoftmaxCrossEntropyCost extends Operation {\n  constructor(\n      private logitsTensor: Tensor, private labelTensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    this.softmaxTensor = new Tensor(logitsTensor.shape);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    const label = inferenceArrays.get(this.labelTensor) as Array1D;\n\n    math.scope((keep) => {\n      const softmaxResult = math.softmax(logits);\n\n      inferenceArrays.set(this.softmaxTensor, keep(softmaxResult));\n      inferenceArrays.set(\n          this.yTensor,\n          keep(crossEntropyCost(math, softmaxResult, label, this.epsilon)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const softmax = inferenceArrays.get(this.softmaxTensor);\n    const label = inferenceArrays.get(this.labelTensor);\n\n    math.scope((keep) => {\n      gradientArrays.set(this.logitsTensor, keep(math.sub(softmax, label)));\n    });\n  }\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {\n    inferenceArrays.disposeArray(this.softmaxTensor);\n  }\n\n  dispose() {\n    this.epsilon.dispose();\n  }\n\n  private softmaxTensor: Tensor;\n  private epsilon = Scalar.new(1e-5);\n}\n\nexport function crossEntropyCost(\n    math: NDArrayMath, y: Array1D, target: Array1D, epsilon: Scalar): Scalar {\n  util.assert(\n      y.size === target.size, 'The output and target must be the same size');\n\n  return math.scope(() => {\n    const yPlusEps = math.scalarPlusArray(epsilon, y);\n    const logOutput = math.log(yPlusEps);\n    const tarLogOutput = math.elementWiseMul(target, logOutput);\n    const costVector = math.neg(tarLogOutput);\n    return math.sum(costVector);\n  });\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * Split ops are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n */\nexport class Split extends Operation {\n  constructor(private input: Tensor, private outputs: Tensor[]) {\n    super();\n    outputs.forEach(output => {\n      util.assertShapesMatch(input.shape, output.shape);\n    });\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const inputArray = inferenceArrays.get(this.input);\n    this.outputs.forEach(output => {\n      inferenceArrays.set(output, inputArray);\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.input)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      let dx = math.add(\n          gradientArrays.get(this.outputs[0]),\n          gradientArrays.get(this.outputs[1]));\n      // Sum across all the derivatives of the consumers of this node.\n      this.outputs.slice(2).forEach(output => {\n        dx = math.add(dx, gradientArrays.get(output));\n      });\n      gradientArrays.set(this.input, keep(dx));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Subtract extends Operation {\n  private dySizeScalar: Scalar;\n\n  /**\n   * Element-wise subtract operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private t1: Tensor, private t2: Tensor, private outTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(t1.shape) === 1 ||\n            util.sizeFromShape(t2.shape) === 1 ||\n            util.arraysEqual(t1.shape, t2.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarMinusArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayMinusScalar(t1, t2);\n      } else {\n        result = math.sub(t1, t2);\n      }\n      inferenceArrays.set(this.outTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.t1)) {\n        if (util.isScalarShape(this.t1.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t1, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t1, keep(dy));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.t2)) {\n        if (util.isScalarShape(this.t2.shape)) {\n          const sum = math.sum(dy);\n          const negSum = math.neg(sum);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t2, keep(math.divide(negSum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t2, keep(math.neg(dy)));\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {SessionRuntime} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport abstract class Optimizer {\n  protected variableNodes: VariableNode[];\n  protected specifiedVariableNodes: VariableNode[]|null;\n\n  constructor(specifiedVariableList?: Node[]) {\n    if (specifiedVariableList != null) {\n      this.specifiedVariableNodes = specifiedVariableList as VariableNode[];\n    }\n  }\n\n  abstract beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract dispose(): void;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * Default comparison function for the priority queue.\n * @param a The first element to compare.\n * @param b The second element to compare.\n * @return \"a > b\" returns > 0. \"a < b\" returns < 0. \"a === b\" returns 0.\n */\nexport function defaultCompare<T>(a: T, b: T): number {\n  if (a === b) {\n    return 0;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * A Comparator is a user-provided function that compares two T instances. The\n * convention for defaultCompare is expected to be followed to maintain the\n * binary min-heap integrity.\n * @param a The first element to compare.\n * @param b The second element to compare.\n */\nexport type Comparator<T> = (a: T, b: T) => number;\n\n/**\n * IndexObserver is a user-provided callback that informs the caller when an\n * element in the priority queue's binary min-heap has been relocated.\n * @param t The element that was relocated.\n * @param newIndex The new location in the binary min-heap of the element.\n */\nexport type IndexObserver<T> = (t: T, newIndex: number) => void;\n\n/**\n * A priority queue, implemented in terms of a binary min-heap. Lower priority\n * numbers are considered higher priority.\n * enqueue, dequeue, and update are all O(log N) with respect to the number of\n * elements in the queue.\n */\nexport class PriorityQueue<T> {\n  private heap: T[] = [];\n\n  /**\n   * @param comparator A function that compares two queue elements.\n   * @param indexObserver An optional callback raised when the priority queue\n   * changes the order of elements in its min-heap. Useful for tracking the\n   * positions of elements that need updating.\n   */\n  constructor(\n      private comparator: Comparator<T>,\n      private indexObserver?: IndexObserver<T>) {}\n\n  /**\n   * Add an element to the priority queue.\n   * @param t The element to enqueue.\n   */\n  enqueue(t: T) {\n    this.heap.push(t);\n    this.onIndexChanged(t, this.heap.length - 1);\n    this.siftUp(this.heap.length - 1);\n  }\n\n  /**\n   * Remove an element from the priority queue.\n   * @return The element in the priority queue with the highest priority\n   * (lowest numeric priority value).\n   */\n  dequeue(): T {\n    if (this.empty()) {\n      throw new Error('dequeue called on empty priority queue.');\n    }\n    const t = this.heap[0];\n    this.swap(0, this.heap.length - 1);\n    this.heap.pop();\n    this.siftDown(0);\n    return t;\n  }\n\n  /**\n   * Updates an element at the specified index. This can be a full element\n   * replacement, or it can be an in-place update. The priority is assumed to be\n   * changed, and the internal storage is updated. This function is only useful\n   * if the storage index of the updated element is known; construct the\n   * PriorityQueue with an IndexObserver to track element locations.\n   * @param newT The new element to replace in the priority queue.\n   * @param index The index to insert the new element into.\n   */\n  update(newT: T, index: number) {\n    /* If the element is at the very end of the heap, no sifting is necessary,\n     * it can be safely removed. */\n    const last = (index === this.heap.length - 1);\n    if (!last) {\n      this.swap(index, this.heap.length - 1);\n    }\n    this.heap.pop();\n    if (!last) {\n      /* The element at 'index' has been removed, and replaced with whatever was\n       * at the end of the heap. Since that element might have come from a\n       * different subtree (and not be a direct descendant of the node at\n       * 'index'), we might need to sift this new value up instead of down. Test\n       * both directions, and sift to wherever the node needs to go.\n       */\n      if (this.siftUpIndex(index) !== -1) {\n        this.siftUp(index);\n      } else if (this.siftDownIndex(index) !== -1) {\n        this.siftDown(index);\n      }\n    }\n    this.enqueue(newT);\n  }\n\n  /**\n   * Predicate for testing whether the PriorityQueue is empty.\n   * @return True if the PriorityQueue is empty, otherwise False.\n   */\n  empty(): boolean {\n    return this.heap.length === 0;\n  }\n\n  private onIndexChanged(t: T, newIndex: number) {\n    if (this.indexObserver) {\n      this.indexObserver(t, newIndex);\n    }\n  }\n\n  /*\n   * Standard zero-indexed binary heap array layout:\n   *   Parent(N) = Floor((N - 1) / 2)\n   *   LeftChild(N) = (N * 2) + 1\n   *   RightChild(N) = (N * 2) + 2\n   */\n\n  private getParentIndex(index: number): number {\n    if (index === 0) {\n      return -1;\n    }\n    return Math.floor((index - 1) / 2);\n  }\n\n  private getLeftChildIndex(index: number): number {\n    const candidate = index * 2 + 1;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private getRightChildIndex(index: number): number {\n    const candidate = index * 2 + 2;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private siftUpIndex(index: number): number {\n    const parentIndex = this.getParentIndex(index);\n    if (parentIndex === -1) {\n      return -1;\n    }\n    if (this.compare(parentIndex, index) > 0) {\n      return parentIndex;\n    }\n    return -1;\n  }\n\n  private siftUp(index: number) {\n    let siftIndex = this.siftUpIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftUpIndex(index);\n    }\n  }\n\n  private siftDownIndex(index: number): number {\n    if (index >= this.heap.length) {\n      return -1;\n    }\n    let largestChildIndex = index;\n    const leftChildIndex = this.getLeftChildIndex(index);\n    if ((leftChildIndex !== -1) &&\n        (this.compare(leftChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = leftChildIndex;\n    }\n    const rightChildIndex = this.getRightChildIndex(index);\n    if ((rightChildIndex !== -1) &&\n        (this.compare(rightChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = rightChildIndex;\n    }\n    return (largestChildIndex === index) ? -1 : largestChildIndex;\n  }\n\n  private siftDown(index: number) {\n    let siftIndex = this.siftDownIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftDownIndex(index);\n    }\n  }\n\n  private compare(aIndex: number, bIndex: number): number {\n    return this.comparator(this.heap[aIndex], this.heap[bIndex]);\n  }\n\n  private swap(a: number, b: number) {\n    const temp = this.heap[a];\n    this.heap[a] = this.heap[b];\n    this.heap[b] = temp;\n    this.onIndexChanged(this.heap[a], a);\n    this.onIndexChanged(this.heap[b], b);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Node, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as operation_emitter from './operation_emitter';\nimport {Operation} from './ops/op';\nimport {Optimizer} from './optimizer';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * FeedEntry associates a tensor with user-provided NDArray data.\n */\nexport type FeedEntry = {\n  tensor: Tensor,\n  data: NDArray|InputProvider\n};\n\n/**\n * A FeedDictionary holds a map from tensors to user-provided NDArrays. Feed\n * dictionaries represent the 'entry points' of evaluation, since graph nodes\n * that are replaced by feeds don't need to have their input nodes evaluated.\n * Feed dictionaries usually provide NDArray data for Placeholder nodes, but any\n * node in the graph can be replaced by a feed dictionary entry.\n *\n * @hidden\n */\nexport class FeedDictionary {\n  dict: {[tensorID: number]: FeedEntry} = {};\n\n  /**\n   * Optionally construct a FeedDictionary from an array of entries.\n   * @param feedEntries Optional array of FeedEntry objects.\n   */\n  constructor(feedEntries?: FeedEntry[]) {\n    if (feedEntries) {\n      feedEntries.forEach(entry => this.dict[entry.tensor.id] = entry);\n    }\n  }\n}\n\nexport enum CostReduction {\n  NONE,\n  SUM,\n  MEAN\n}\n\n/**\n * A Session maintains the runtime state required to efficiently evaluate nodes.\n * On their own, graph objects are very lightweight logical topologies; they\n * have no relationship with the GPU. Sessions encapsulate the evaluation of\n * nodes, the management of GPU resources, the caching of evaluation paths, and\n * anything else required to evaluate or train a network.\n */\nexport class Session {\n  /**\n   * @param graph The graph to associate with this Session.\n   * @param math The NDArrayMath interface that this Session should use.\n   */\n  constructor(private graph: Graph, private math: NDArrayMath) {}\n\n  /**\n   * Release all system resources associated with this Session.\n   */\n  dispose() {\n    this.activationArrayMap.dispose();\n    Object.keys(this.runtimeCache).forEach(key => {\n      const runtime = this.runtimeCache[key];\n      if (runtime.operations) {\n        runtime.operations.forEach(op => op.dispose());\n      }\n    });\n    this.runtimeCache = {};\n    if (this.batchSizeScalar != null) {\n      this.batchSizeScalar.dispose();\n    }\n    this.oneScalar.dispose();\n  }\n\n  /**\n   * Evaluate a list of tensors, using the provided feed entries to provide\n   * upstream NDArray input.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param tensors The list of tensors to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed values of the tensors.\n   */\n  evalAll(tensors: Tensor[], feedEntries: FeedEntry[]): NDArray[] {\n    return this.math.scope(() => {\n      const feed = new FeedDictionary(feedEntries);\n      const runtime = this.getOrCreateRuntime(tensors, feed);\n\n      const activations = this.activationArrayMap;\n\n      session_util.disposeAndInitializeOperationOutputs(\n          runtime.nodes, activations);\n      session_util.disposeTransientOperationArrays(\n          runtime.operations, this.activationArrayMap, this.gradientArrayMap);\n\n      session_util.addPersistentArraysToTensorArrayMap(\n          runtime.nodes, activations);\n      session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n          feed, activations, this.math);\n\n      runtime.operations.forEach(op => op.feedForward(this.math, activations));\n\n      const results = tensors.map(x => activations.get(x));\n      tensors.forEach(x => activations.delete(x));\n\n      session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n          feed, activations, this.math);\n\n      return results;\n    });\n  }\n\n  /**\n   * Evaluate a tensor, using the provided feed entries to provide\n   * upstream NDArray input.\n   *\n   * @param tensor The tensor to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed value of the tensor.\n   */\n  eval(tensor: Tensor, feedEntries: FeedEntry[]): NDArray {\n    return this.evalAll([tensor], feedEntries)[0];\n  }\n\n  /**\n   * Trains a batch.\n   * Returns a reduced cost if the costReduction parameter is set.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param costTensor A tensor representing the cost to optimize. Should be a\n   * scalar.\n   * @param feedEntries Feed entries for this train run. Provides inputs.\n   * @param batchSize Batch size for this train loop.\n   * @param optimizer An optimizer to perform weight updates.\n   * @param costReduction An option to allow the user to get a summed, averaged,\n   * or no cost back.\n   * @return The reduced cost, if cost reduction is not NONE. The user is\n   * responsible for disposing the cost NDArray between train loops.\n   */\n  train(\n      costTensor: Tensor, feedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, costReduction = CostReduction.NONE): Scalar {\n    util.assert(\n        util.isScalarShape(costTensor.shape),\n        'Cost tensor for training must be a scalar value.');\n\n    if (this.prevBatchSize !== batchSize) {\n      this.prevBatchSize = batchSize;\n      this.batchSizeScalar = Scalar.new(batchSize);\n    }\n\n    const feed = new FeedDictionary(feedEntries);\n    session_util.throwIfFeedDictionaryContainsNDArrays(feed);\n\n    const runtime = this.getOrCreateRuntime([costTensor], feed);\n    const inferenceOperations = runtime.operations;\n    const backPropOperations = runtime.operations.slice().reverse();\n    const activations = this.activationArrayMap;\n    const gradients = this.gradientArrayMap;\n    gradients.set(costTensor, this.oneScalar);\n\n    session_util.addPersistentArraysToTensorArrayMap(\n        runtime.nodes, activations);\n\n    optimizer.beforeBatch(\n        this.math, batchSize, runtime, activations, gradients);\n\n    return this.math.scope((keep, track) => {\n      let cost = track(Scalar.new(0));\n\n      for (let i = 0; i < batchSize; ++i) {\n        session_util.disposeAndInitializeOperationOutputs(\n            runtime.nodes, activations);\n        session_util.disposeAndInitializeOperationInputGradients(\n            runtime.nodes, gradients);\n        session_util.disposeTransientOperationArrays(\n            runtime.operations, activations, gradients);\n\n        session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n            feed, activations, this.math);\n\n        inferenceOperations.forEach(\n            op => op.feedForward(this.math, activations));\n        backPropOperations.forEach(\n            op => op.backProp(this.math, activations, gradients));\n\n        optimizer.afterExample(this.math, runtime, activations, gradients);\n\n        session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n            feed, activations, this.math);\n\n        cost = this.updateCostForExample(\n            cost, activations.get(costTensor), costReduction);\n      }\n\n      optimizer.afterBatch(\n          this.math, batchSize, runtime, activations, gradients);\n\n      return this.updateCostForBatch(cost, costReduction);\n    });\n  }\n\n  private updateCostForExample(\n      totalCost: Scalar, currCost: Scalar,\n      costReduction: CostReduction): Scalar {\n    if (costReduction === CostReduction.MEAN ||\n        costReduction === CostReduction.SUM) {\n      return this.math.add(totalCost, currCost);\n    }\n    return totalCost;\n  }\n\n  private updateCostForBatch(totalCost: Scalar, costReduction: CostReduction):\n      Scalar {\n    if (costReduction === CostReduction.MEAN) {\n      return this.math.divide(totalCost, this.batchSizeScalar);\n    }\n    return totalCost;\n  }\n\n  private getOrCreateRuntime(tensors: Tensor[], feed: FeedDictionary):\n      SessionRuntime {\n    const key = this.makeRuntimeCacheKey(tensors, feed);\n    let runtime = this.runtimeCache[key];\n    if (runtime === undefined) {\n      let nodes =\n          session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed);\n      // In inference mode split nodes are not needed, but their cost is\n      // negligible, and always adding them in allows for caching of 1 runtime\n      // for both train/eval.\n      nodes = session_util.addSplitNodes(nodes);\n      session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes);\n      session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes);\n      const operations = operation_emitter.emitFromGraphNodes(nodes);\n      runtime = {nodes, operations};\n      this.runtimeCache[key] = runtime;\n    }\n\n    return runtime;\n  }\n\n  private makeRuntimeCacheKey(tensors: Tensor[], feed: FeedDictionary): string {\n    return tensors.map(x => x.id).sort().join('_') + '__' +\n        Object.keys(feed.dict).sort().join('_');\n  }\n\n  /** Maps each output tensor of the graph to its activation value. */\n  activationArrayMap = new TensorArrayMap();\n  /** Maps each tensor of the graph to its derivative wrt the cost function. */\n  gradientArrayMap = new TensorArrayMap();\n  private runtimeCache: {[key: string]: SessionRuntime} = {};\n  /** Batch size of the previous train() call. */\n  private prevBatchSize: number;\n  private batchSizeScalar: Scalar;\n  private oneScalar = Scalar.new(1);\n}\n\n/** @hidden */\nexport type SessionRuntime = {\n  nodes: Node[]; operations: Operation[];\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport {Operation} from './ops/op';\nimport {FeedDictionary} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * Creates an array of graph nodes that stop traversal, based on the contents\n * of the provided FeedDictionary. This is a simple 1:1 extraction of nodes from\n * the FeedDictionary.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to scan for termination nodes.\n * @return an array of Nodes which halt traversal when visited.\n */\nexport function getTerminatingNodesFromFeedDictionary(\n    feedDictionary: FeedDictionary): Node[] {\n  return Object.keys(feedDictionary.dict)\n      .map(tensorID => feedDictionary.dict[+tensorID].tensor.node);\n}\n\n/**\n * Given a tensor and a feed dictionary, computes the set of nodes that need to\n * be evaluated to perform inference.\n *\n * @hidden\n * @param evalTensors The list of tensors to eventually be evaluated.\n * @param feedDictionary The populated feed dictionary.\n * @return The set of nodes to evaluate, in evaluation order.\n */\nexport function getOrderedEvaluationSetFromEvalTensor(\n    evalTensors: Tensor[], feedDictionary: FeedDictionary): Node[] {\n  const terminatingNodes =\n      getTerminatingNodesFromFeedDictionary(feedDictionary);\n  const evalNodes = evalTensors.map(x => x.node);\n  const unorderedEvaluationSet =\n      graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes);\n  const orderedEvaluationSet =\n      graph_util.getOrderedEvaluationSet(unorderedEvaluationSet);\n  return orderedEvaluationSet;\n}\n\n/**\n * Traverses the provided node array and adds all persistent node NDArrays to\n * the provided TensorArrayMap.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n * @param tensorArrayMap The map that receives the NDArrays from persistent\n * nodes.\n */\nexport function addPersistentArraysToTensorArrayMap(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode || node instanceof ConstantNode) {\n      tensorArrayMap.set(node.output, node.data);\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function getVariableNodesFromEvaluationSet(evaluationSet: Node[]):\n    VariableNode[] {\n  const nodes: VariableNode[] = [];\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode) {\n      nodes.push(node);\n    }\n  });\n  return nodes;\n}\n\n/**\n * @hidden\n */\nexport function throwIfFeedDictionaryContainsNDArrays(\n    feedDictionary: FeedDictionary) {\n  Object.keys(feedDictionary.dict).forEach(tensorID => {\n    if (feedDictionary.dict[+tensorID].data instanceof NDArray) {\n      throw new Error(\n          'training requires FeedDictionary entries to be InputProviders' +\n          'and not NDArrays.');\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function loadInputsFromFeedDictionaryToTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    let data: NDArray;\n    if (feedEntry.data instanceof NDArray) {\n      data = feedEntry.data as NDArray;\n    } else {\n      const provider = feedEntry.data as InputProvider;\n      data = provider.getNextCopy(math);\n    }\n\n    util.assert(\n        util.arraysEqual(feedEntry.tensor.shape, data.shape),\n        `Error loading FeedEntry: feeding NDArray of shape ${data.shape} ` +\n            `does not match Tensor (id: ${feedEntry.tensor.id}) shape: ` +\n            `${feedEntry.tensor.shape}.`);\n    activations.set(feedEntry.tensor, data);\n  });\n}\n\n\n/**\n * @hidden\n */\nexport function releaseFeedDictionaryInputsFromTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    if (!(feedEntry.data instanceof NDArray)) {\n      const provider = feedEntry.data as InputProvider;\n\n      const feedEntryArray = activations.get(feedEntry.tensor);\n      provider.disposeCopy(math, feedEntryArray);\n    }\n\n    activations.delete(feedEntry.tensor);\n  });\n}\n\n/**\n * Removes all nodes from the provided Node array whose output tensors exist in\n * the provided feed dictionary. After calling this, the Node array should\n * contain zero Placeholder nodes, or the user has failed to provide a feed for\n * a Placeholder node.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to process.\n * @param evaluationSet The array of nodes to remove input nodes from.\n */\nexport function removeFeedDictionaryNodesFromEvaluationSet(\n    feedDictionary: FeedDictionary, evaluationSet: Node[]) {\n  let i = 0;\n  while (i < evaluationSet.length) {\n    const node = evaluationSet[i];\n    if (feedDictionary.dict[node.output.id] != null) {\n      evaluationSet.splice(i, 1);\n    } else {\n      ++i;\n    }\n  }\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from operation outputs and sets\n * the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param tensorArrayMap The map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationOutputs(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (!graph_util.isInputNode(node)) {\n      if (!graph_util.isPassthroughNode(node, tensorArrayMap)) {\n        tensorArrayMap.disposeArray(node.output);\n      }\n      tensorArrayMap.set(node.output, null);\n    }\n  });\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from derivatives of operation\n * inputs and sets the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param gradients The gradient map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationInputGradients(\n    evaluationSet: Node[], gradients: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    Object.keys(node.inputs).forEach(inputName => {\n      const input = node.inputs[inputName];\n      if (gradients.get(input, true) !== gradients.get(node.output, true)) {\n        gradients.disposeArray(input);\n      }\n      gradients.set(input, null);\n    });\n  });\n}\n\n\n/**\n * Calls underlying operation disposeTransientArrays methods which clean up any\n * NDArrays which operations may have created during a run.\n *\n * @hidden\n * @param operationNodes The array of Nodes to traverse.\n * @param outputTensor The tensor being evaluated.\n * @param map The TensorArrayMap to operate on.\n */\nexport function disposeTransientOperationArrays(\n    operations: Operation[], activations: TensorArrayMap,\n    gradients: TensorArrayMap) {\n  operations.forEach(op => op.disposeTransientArrays(activations, gradients));\n}\n\n/**\n * Iterates the provided Node array and throws an exception if there are any\n * Placeholder nodes present. Call after the evaluation set has been pruned with\n * the accompanying FeedDictionary to ensure that all inputs have been resolved.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n */\nexport function throwErrorIfEvaluationSetContainsPlaceholderNodes(\n    evaluationSet: Node[]) {\n  evaluationSet.forEach(node => {\n    if (node instanceof PlaceholderNode) {\n      const shape = '[' + node.output.shape.join(', ') + ']';\n      throw new Error(\n          'Placeholder node \"' + node.name + '\" ' + shape +\n          ' not present in feed dictionary.');\n    }\n  });\n}\n\n/**\n * Injects splits nodes after every node that has multiple consumers.\n *\n * @hidden\n * @param nodes The node list in evaluation order.\n * @return The node list with split nodes injected.\n */\nexport function addSplitNodes(nodes: Node[]): Node[] {\n  const nodeIdToNumConsumers: number[] = [];\n  const nodeIdToSplitNode: {[nodeId: number]: SplitNode} = {};\n\n  // Find nodes that have multiple consumers.\n  nodes.forEach(node => {\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const input = inputTensor.node;\n      if (nodeIdToNumConsumers[input.id] == null) {\n        nodeIdToNumConsumers[input.id] = 0;\n      }\n      nodeIdToNumConsumers[input.id]++;\n      if (nodeIdToNumConsumers[input.id] > 1 &&\n          nodeIdToSplitNode[input.id] == null) {\n        nodeIdToSplitNode[input.id] = new SplitNode(input.graph, inputTensor);\n      }\n    });\n  });\n\n  // Inject a split node after each node that has multiple consumers and\n  // rewire the inputs of the consumers to consume the output tensors of the\n  // split node instead of the original node. Each consumer consumes a\n  // different output tensor so that derivatives are not overwritten.\n  // x-->y  becomes x-->s-->y   where y consumes the 1st output tensor of s\n  // |-->z              |-->z     and z consumes the 2nd output tensor of s\n  const newNodes: Node[] = [];\n  nodes.forEach(node => {\n    newNodes.push(node);\n    if (node.id in nodeIdToSplitNode) {\n      const splitNode = nodeIdToSplitNode[node.id];\n      newNodes.push(splitNode);\n    }\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const inputId = inputTensor.node.id;\n      if (inputId in nodeIdToSplitNode) {\n        node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor();\n      }\n    });\n  });\n  return newNodes;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {SessionRuntime} from './session';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport class SGDOptimizer extends Optimizer {\n  constructor(private learningRate: number, specifiedVariableList?: Node[]) {\n    super(specifiedVariableList);\n  }\n\n  beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    this.variableNodes = this.specifiedVariableNodes == null ?\n        session_util.getVariableNodesFromEvaluationSet(runtime.nodes) :\n        this.specifiedVariableNodes;\n    if (batchSize !== this.prevBatchSize) {\n      this.prevBatchSize = batchSize;\n      this.c = Scalar.new(-this.learningRate / batchSize);\n    }\n    this.variableNodes.forEach(\n        node => this.variableGradients.set(\n            node.output, NDArray.zeros(node.output.shape)));\n  }\n\n  afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const gradient = gradientArrayMap.get(node.output);\n        const accumulatedGradient = this.variableGradients.get(node.output);\n        this.variableGradients.set(\n            node.output, keep(math.add(gradient, accumulatedGradient)));\n        accumulatedGradient.dispose();\n      });\n    });\n  }\n\n  afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const oldVariable = activationArrayMap.get(node.output);\n        const gradient = this.variableGradients.get(node.output);\n        const variable =\n            math.scaledArrayAdd(this.c!, gradient, this.one!, oldVariable);\n        activationArrayMap.set(node.output, keep(variable));\n        node.data = variable;\n\n        oldVariable.dispose();\n      });\n    });\n\n    this.variableGradients.dispose();\n    this.variableGradients = new TensorArrayMap();\n  }\n\n  dispose() {\n    if (this.c != null) {\n      this.c.dispose();\n    }\n    this.one.dispose();\n  }\n\n  setLearningRate(learningRate: number) {\n    this.learningRate = learningRate;\n  }\n\n  private variableGradients = new TensorArrayMap();\n  private prevBatchSize: number;\n  private one = Scalar.new(1);\n  private c: Scalar;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from './graph';\nimport {NDArray} from './math/ndarray';\n\n/**\n * TensorArrayMap is an internal map from Tensor IDs to NDArrays. Since NDArrays\n * can be backed by WebGL textures, the TensorArrayMap is only used inside of a\n * Session.\n */\nexport class TensorArrayMap {\n  /**\n   * Add or replace an entry in the map.\n   * @param tensor The tensor key.\n   * @param array The NDArray value, can be null.\n   */\n  set(tensor: Tensor, array: NDArray|null) {\n    this.dict[tensor.id] = array;\n  }\n\n  /**\n   * Returns the NDArray associated with the provided tensor. Will throw an\n   * exception if the tensor is not a key in the map, or if the associated\n   * NDArray is null.\n   * @param tensor The tensor key.\n   * @param skipChecks False by default. If true will skip all checks.\n   * @return The NDArray associated with the tensor.\n   */\n  get(tensor: Tensor, skipChecks = false): NDArray {\n    if (!skipChecks && this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    const nda = this.dict[tensor.id];\n    if (!skipChecks && nda === null) {\n      throw new Error('tensor ' + tensor.id + ' has null array.');\n    }\n    return nda!;\n  }\n\n  /**\n   * Removes a tensor/NDArray pair from the map.\n   * @param tensor The tensor key.\n   */\n  delete(tensor: Tensor) {\n    delete this.dict[tensor.id];\n  }\n\n  disposeArray(tensor: Tensor) {\n    if (this.dict[tensor.id] === undefined) {\n      return;\n    }\n    const nda = this.dict[tensor.id];\n    if (nda === null) {\n      return;\n    }\n    nda.dispose();\n    this.dict[tensor.id] = null;\n  }\n\n  /**\n   * @return The number of tensor/NDArray pairs in the map.\n   */\n  size(): number {\n    return Object.keys(this.dict).length;\n  }\n\n  /**\n   * Iterate over all contained NDArray values and dispose them.\n   */\n  dispose() {\n    Object.keys(this.dict).forEach(tensorID => {\n      const nda = this.dict[+tensorID];\n      if (nda) {\n        nda.dispose();\n      }\n    });\n    this.dict = {};\n  }\n\n  /**\n   * Tests to see if a tensor has a null associated with it. Throws\n   * if the tensor is not a key in the map.\n   * @param tensor The tensor key.\n   * @return True if the associated NDArray is null, else False.\n   */\n  hasNullArray(tensor: Tensor): boolean {\n    if (this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    return this.dict[tensor.id] === null;\n  }\n\n  private dict: {[tensorID: number]: NDArray | null} = {};\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport type Vector = number[] | Float64Array | Float32Array | Int32Array |\n    Int8Array | Int16Array;\n\n/** Shuffles the array using Fisher-Yates algorithm. */\n// tslint:disable-next-line:no-any\nexport function shuffle(array: any[]|Uint32Array|Int32Array|\n                        Float32Array): void {\n  let counter = array.length;\n  let temp = 0;\n  let index = 0;\n  // While there are elements in the array\n  while (counter > 0) {\n    // Pick a random index\n    index = (Math.random() * counter) | 0;\n    // Decrease counter by 1\n    counter--;\n    // And swap the last element with it\n    temp = array[counter];\n    array[counter] = array[index];\n    array[index] = temp;\n  }\n}\n\n/** Clamps a value to a specified range. */\nexport function clamp(min: number, x: number, max: number): number {\n  return Math.max(min, Math.min(x, max));\n}\n\n/** Returns a sample from a uniform [a, b] distribution. */\nexport function randUniform(a: number, b: number) {\n  return Math.random() * (b - a) + a;\n}\n\n/**\n * Samples from a gaussian distribution.\n *\n * @param mean The mean. Default is 0.\n * @param stdDev The standard deviation. Default is 1.\n */\nexport function randGauss(mean = 0, stdDev = 1, truncated = false): number {\n  let v1: number, v2: number, s: number;\n  do {\n    v1 = 2 * Math.random() - 1;\n    v2 = 2 * Math.random() - 1;\n    s = v1 * v1 + v2 * v2;\n  } while (s > 1);\n\n  const result = Math.sqrt(-2 * Math.log(s) / s) * v1;\n  if (truncated && result > 2) {\n    return randGauss(mean, stdDev, true);\n  }\n  return mean + stdDev * result;\n}\n\n/** Returns squared eucledian distance between two vectors. */\nexport function distSquared(a: Vector, b: Vector): number {\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    const diff = a[i] - b[i];\n    result += diff * diff;\n  }\n  return result;\n}\n\nexport function assert(expr: boolean, msg: string) {\n  if (!expr) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertShapesMatch(\n    shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void {\n  assert(\n      arraysEqual(shapeA, shapeB),\n      errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`);\n}\n\n// tslint:disable-next-line:no-any\nexport function flatten(arr: any[], ret?: number[]): number[] {\n  ret = (ret === undefined ? [] : ret);\n  for (let i = 0; i < arr.length; ++i) {\n    if (Array.isArray(arr[i])) {\n      flatten(arr[i], ret);\n    } else {\n      ret.push(arr[i]);\n    }\n  }\n  return ret;\n}\n\nexport type ArrayData = number|number[]|number[][]|number[][][]|number[][][][];\n\nexport function inferShape(arr: ArrayData): number[] {\n  const shape: number[] = [];\n  while (arr instanceof Array) {\n    shape.push(arr.length);\n    arr = arr[0];\n  }\n  return shape;\n}\n\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\n\nexport function isScalarShape(shape: number[]): boolean {\n  return shape.length === 0;\n}\n\n// tslint:disable-next-line:no-any\nexport function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) {\n  if (n1.length !== n2.length) {\n    return false;\n  }\n  for (let i = 0; i < n1.length; i++) {\n    if (n1[i] !== n2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\n\nexport function tanh(x: number): number {\n  // tslint:disable-next-line:no-any\n  if ((Math as any).tanh != null) {\n    // tslint:disable-next-line:no-any\n    return (Math as any).tanh(x);\n  }\n  if (x === Infinity) {\n    return 1;\n  } else if (x === -Infinity) {\n    return -1;\n  } else {\n    const e2x = Math.exp(2 * x);\n    return (e2x - 1) / (e2x + 1);\n  }\n}\n\nexport function sizeToSquarishShape(size: number): [number, number] {\n  for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) {\n    if (size % a === 0) {\n      return [a, size / a];\n    }\n  }\n  return [1, size];\n}\n\nexport function createShuffledIndices(n: number): Uint32Array {\n  const shuffledIndices = new Uint32Array(n);\n  for (let i = 0; i < n; ++i) {\n    shuffledIndices[i] = i;\n  }\n  shuffle(shuffledIndices);\n  return shuffledIndices;\n}\n"]} diff --git a/demos/model-builder/cifar10-conv.json b/demos/model-builder/cifar10-conv.json new file mode 100644 index 0000000000..152d1ac230 --- /dev/null +++ b/demos/model-builder/cifar10-conv.json @@ -0,0 +1 @@ +[{"layerName":"Convolution","fieldSize":5,"stride":1,"zeroPad":2,"outputDepth":16},{"layerName":"ReLU"},{"layerName":"Max pool","fieldSize":2,"stride":2,"zeroPad":0},{"layerName":"Convolution","fieldSize":5,"stride":1,"zeroPad":2,"outputDepth":20},{"layerName":"ReLU"},{"layerName":"Max pool","fieldSize":2,"stride":2,"zeroPad":0},{"layerName":"Convolution","fieldSize":5,"stride":1,"zeroPad":2,"outputDepth":20},{"layerName":"ReLU"},{"layerName":"Max pool","fieldSize":2,"stride":2,"zeroPad":0},{"layerName":"Flatten"},{"layerName":"Fully connected","hiddenUnits":10}] \ No newline at end of file diff --git a/demos/model-builder/layer_builder.ts b/demos/model-builder/layer_builder.ts new file mode 100644 index 0000000000..743865356d --- /dev/null +++ b/demos/model-builder/layer_builder.ts @@ -0,0 +1,370 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Array1D, Array2D, Array4D, conv_util, Graph, Initializer, NDArray, NDArrayInitializer, Tensor, util, VarianceScalingInitializer, ZerosInitializer} from '../deeplearnjs'; + +/** + * Classes that specify operation parameters, how they affect output shape, + * and methods for building the operations themselves. Any new ops to be added + * to the model builder UI should be added here. + */ + +export type LayerName = 'Fully connected' | 'ReLU' | 'Convolution' | + 'Max pool' | 'Reshape' | 'Flatten'; + +/** + * Creates a layer builder object. + * + * @param layerName The name of the layer to build. + * @param layerBuilderJson An optional LayerBuilder JSON object. This doesn't + * have the prototype methods on them as it comes from serialization. This + * method creates the object with the necessary prototype methods. + */ +export function getLayerBuilder( + layerName: LayerName, layerBuilderJson?: LayerBuilder): LayerBuilder { + let layerBuilder: LayerBuilder; + switch (layerName) { + case 'Fully connected': + layerBuilder = new FullyConnectedLayerBuilder(); + break; + case 'ReLU': + layerBuilder = new ReLULayerBuilder(); + break; + case 'Convolution': + layerBuilder = new Convolution2DLayerBuilder(); + break; + case 'Max pool': + layerBuilder = new MaxPoolLayerBuilder(); + break; + case 'Reshape': + layerBuilder = new ReshapeLayerBuilder(); + break; + case 'Flatten': + layerBuilder = new FlattenLayerBuilder(); + break; + default: + throw new Error('Layer builder for ' + layerName + ' not found.'); + } + + // For layer builders passed as serialized objects, we create the objects and + // set the fields. + if (layerBuilderJson != null) { + for (const prop in layerBuilderJson) { + if (layerBuilderJson.hasOwnProperty(prop)) { + // tslint:disable-next-line:no-any + (layerBuilder as any)[prop] = (layerBuilderJson as any)[prop]; + } + } + } + return layerBuilder; +} + +export interface LayerParam { + label: string; + initialValue(inputShape: number[]): number|string; + type: 'number'|'text'; + min?: number; + max?: number; + setValue(value: number|string): void; + getValue(): number|string; +} + +export type LayerWeightsDict = { + [name: string]: number[] +}; + +export interface LayerBuilder { + layerName: LayerName; + getLayerParams(): LayerParam[]; + getOutputShape(inputShape: number[]): number[]; + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights?: LayerWeightsDict|null): Tensor; + // Return null if no errors, otherwise return an array of errors. + validate(inputShape: number[]): string[]|null; +} + +export class FullyConnectedLayerBuilder implements LayerBuilder { + layerName: LayerName = 'Fully connected'; + hiddenUnits: number; + + getLayerParams(): LayerParam[] { + return [{ + label: 'Hidden units', + initialValue: (inputShape: number[]) => 10, + type: 'number', + min: 1, + max: 1000, + setValue: (value: number) => this.hiddenUnits = value, + getValue: () => this.hiddenUnits + }]; + } + + getOutputShape(inputShape: number[]): number[] { + return [this.hiddenUnits]; + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + const inputSize = util.sizeFromShape(inputShape); + const wShape: [number, number] = [this.hiddenUnits, inputSize]; + + let weightsInitializer: Initializer; + let biasInitializer: Initializer; + if (weights != null) { + weightsInitializer = + new NDArrayInitializer(Array2D.new(wShape, weights['W'])); + biasInitializer = new NDArrayInitializer(Array1D.new(weights['b'])); + } else { + weightsInitializer = new VarianceScalingInitializer(); + biasInitializer = new ZerosInitializer(); + } + + const useBias = true; + return g.layers.dense( + 'fc1', network, this.hiddenUnits, null, useBias, weightsInitializer, + biasInitializer); + } + + validate(inputShape: number[]) { + if (inputShape.length !== 1) { + return ['Input shape must be a Array1D.']; + } + return null; + } +} + +export class ReLULayerBuilder implements LayerBuilder { + layerName: LayerName = 'ReLU'; + getLayerParams(): LayerParam[] { + return []; + } + + getOutputShape(inputShape: number[]): number[] { + return inputShape; + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + return g.relu(network); + } + + validate(inputShape: number[]): string[]|null { + return null; + } +} + +export class Convolution2DLayerBuilder implements LayerBuilder { + layerName: LayerName = 'Convolution'; + fieldSize: number; + stride: number; + zeroPad: number; + outputDepth: number; + + getLayerParams(): LayerParam[] { + return [ + { + label: 'Field size', + initialValue: (inputShape: number[]) => 3, + type: 'number', + min: 1, + max: 100, + setValue: (value: number) => this.fieldSize = value, + getValue: () => this.fieldSize + }, + { + label: 'Stride', + initialValue: (inputShape: number[]) => 1, + type: 'number', + min: 1, + max: 100, + setValue: (value: number) => this.stride = value, + getValue: () => this.stride + }, + { + label: 'Zero pad', + initialValue: (inputShape: number[]) => 0, + type: 'number', + min: 0, + max: 100, + setValue: (value: number) => this.zeroPad = value, + getValue: () => this.zeroPad + }, + { + label: 'Output depth', + initialValue: (inputShape: number[]) => + this.outputDepth != null ? this.outputDepth : 1, + type: 'number', + min: 1, + max: 1000, + setValue: (value: number) => this.outputDepth = value, + getValue: () => this.outputDepth + } + ]; + } + + getOutputShape(inputShape: number[]): number[] { + return conv_util.computeOutputShape3D( + inputShape as [number, number, number], this.fieldSize, + this.outputDepth, this.stride, this.zeroPad); + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + const inputShape3d = inputShape as [number, number, number]; + const wShape: [number, number, number, number] = + [this.fieldSize, this.fieldSize, inputShape[2], this.outputDepth]; + let w: Array4D; + let b: Array1D; + if (weights != null) { + w = Array4D.new(wShape, weights['W']); + b = Array1D.new(weights['b']); + } else { + w = NDArray.randTruncatedNormal(wShape, 0, 0.1); + b = Array1D.zeros([this.outputDepth]); + } + const wTensor = g.variable('conv2d-' + index + '-w', w); + const bTensor = g.variable('conv2d-' + index + '-b', b); + return g.conv2d( + network, wTensor, bTensor, this.fieldSize, this.outputDepth, + this.stride, this.zeroPad); + } + + validate(inputShape: number[]) { + if (inputShape.length !== 3) { + return ['Input shape must be a Array3D.']; + } + return null; + } +} + +export class MaxPoolLayerBuilder implements LayerBuilder { + layerName: LayerName = 'Max pool'; + fieldSize: number; + stride: number; + zeroPad: number; + + getLayerParams(): LayerParam[] { + return [ + { + label: 'Field size', + initialValue: (inputShape: number[]) => 3, + type: 'number', + min: 1, + max: 100, + setValue: (value: number) => this.fieldSize = value, + getValue: () => this.fieldSize + }, + { + label: 'Stride', + initialValue: (inputShape: number[]) => 1, + type: 'number', + min: 1, + max: 100, + setValue: (value: number) => this.stride = value, + getValue: () => this.stride + }, + { + label: 'Zero pad', + initialValue: (inputShape: number[]) => 0, + type: 'number', + min: 0, + max: 100, + setValue: (value: number) => this.zeroPad = value, + getValue: () => this.zeroPad + } + ]; + } + + getOutputShape(inputShape: number[]): number[] { + return conv_util.computeOutputShape3D( + inputShape as [number, number, number], this.fieldSize, inputShape[2], + this.stride, this.zeroPad); + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + return g.maxPool(network, this.fieldSize, this.stride, this.zeroPad); + } + + validate(inputShape: number[]) { + if (inputShape.length !== 3) { + return ['Input shape must be a Array3D.']; + } + return null; + } +} + +export class ReshapeLayerBuilder implements LayerBuilder { + layerName: LayerName = 'Reshape'; + outputShape: number[]; + getLayerParams() { + return [{ + label: 'Shape (comma separated)', + initialValue: (inputShape: number[]) => inputShape.join(', '), + type: 'text' as 'text', + setValue: (value: string) => this.outputShape = + value.split(',').map((value) => +value), + getValue: () => this.outputShape.join(', ') + }]; + } + + getOutputShape(inputShape: number[]): number[] { + return this.outputShape; + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + return g.reshape(network, this.outputShape); + } + + validate(inputShape: number[]) { + const inputSize = util.sizeFromShape(inputShape); + const outputSize = util.sizeFromShape(this.outputShape); + if (inputSize !== outputSize) { + return [ + `Input size (${inputSize}) must match output size (${outputSize}).` + ]; + } + return null; + } +} + +export class FlattenLayerBuilder implements LayerBuilder { + layerName: LayerName = 'Flatten'; + + getLayerParams(): LayerParam[] { + return []; + } + + getOutputShape(inputShape: number[]): number[] { + return [util.sizeFromShape(inputShape)]; + } + + addLayer( + g: Graph, network: Tensor, inputShape: number[], index: number, + weights: LayerWeightsDict|null): Tensor { + return g.reshape(network, this.getOutputShape(inputShape)); + } + + validate(inputShape: number[]): string[]|null { + return null; + } +} diff --git a/demos/model-builder/mnist-conv.json b/demos/model-builder/mnist-conv.json new file mode 100644 index 0000000000..49d826f60d --- /dev/null +++ b/demos/model-builder/mnist-conv.json @@ -0,0 +1 @@ +[{"layerName":"Convolution","fieldSize":5,"stride":1,"zeroPad":2,"outputDepth":8},{"layerName":"ReLU"},{"layerName":"Max pool","fieldSize":2,"stride":2,"zeroPad":0},{"layerName":"Convolution","fieldSize":5,"stride":1,"zeroPad":2,"outputDepth":16},{"layerName":"ReLU"},{"layerName":"Max pool","fieldSize":2,"stride":2,"zeroPad":0},{"layerName":"Flatten"},{"layerName":"Fully connected","hiddenUnits":10}] diff --git a/demos/model-builder/mnist-fully-connected.json b/demos/model-builder/mnist-fully-connected.json new file mode 100644 index 0000000000..8dab4bccc6 --- /dev/null +++ b/demos/model-builder/mnist-fully-connected.json @@ -0,0 +1 @@ +[{"layerName":"Flatten"},{"layerName":"Fully connected","hiddenUnits":128},{"layerName":"ReLU"},{"layerName":"Fully connected","hiddenUnits":32},{"layerName":"ReLU"},{"layerName":"Fully connected","hiddenUnits":10}] diff --git a/demos/model-builder/model-builder-datasets-config.json b/demos/model-builder/model-builder-datasets-config.json new file mode 100644 index 0000000000..e4901d604d --- /dev/null +++ b/demos/model-builder/model-builder-datasets-config.json @@ -0,0 +1,43 @@ +{ + "MNIST": { + "data": [{ + "name": "images", + "path": "https://storage.googleapis.com/learnjs-data/model-builder/mnist_images.png", + "dataType": "png", + "shape": [28, 28, 1] + }, { + "name": "labels", + "path": "https://storage.googleapis.com/learnjs-data/model-builder/mnist_labels_uint8", + "dataType": "uint8", + "shape": [10] + }], + "modelConfigs": { + "Fully connected": { + "name": "Fully connected", + "path": "mnist-fully-connected.json" + }, + "Convolutional": { + "path": "mnist-conv.json" + } + } + }, + "CIFAR 10": { + "data": [{ + "name": "images", + "path": "https://storage.googleapis.com/learnjs-data/model-builder/cifar10_images.png", + "dataType": "png", + "shape": [32, 32, 3] + }, { + "name": "labels", + "path": "https://storage.googleapis.com/learnjs-data/model-builder/cifar10_labels_uint8", + "dataType": "uint8", + "shape": [10] + }], + "labelClassNames": ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"], + "modelConfigs": { + "Convolutional": { + "path": "cifar10-conv.json" + } + } + } +} diff --git a/demos/model-builder/model-builder-demo.html b/demos/model-builder/model-builder-demo.html new file mode 100644 index 0000000000..9417369509 --- /dev/null +++ b/demos/model-builder/model-builder-demo.html @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + LearnJS Demo Page + + + + + + + + + + diff --git a/demos/model-builder/model-builder.html b/demos/model-builder/model-builder.html new file mode 100644 index 0000000000..9dd025560f --- /dev/null +++ b/demos/model-builder/model-builder.html @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/demos/model-builder/model-builder.ts b/demos/model-builder/model-builder.ts new file mode 100644 index 0000000000..b913842052 --- /dev/null +++ b/demos/model-builder/model-builder.ts @@ -0,0 +1,839 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +// tslint:disable-next-line:no-unused-variable +import '../ndarray-image-visualizer'; +import '../ndarray-logits-visualizer'; +import './model-layer'; +import '../demo-header'; +import '../demo-footer'; + +import {Array1D, Array3D, DataStats, FeedEntry, Graph, GraphRunner, GraphRunnerEventObserver, InCPUMemoryShuffledInputProviderBuilder, InMemoryDataset, MetricReduction, NDArray, NDArrayMath, NDArrayMathCPU, NDArrayMathGPU, Optimizer, Scalar, Session, SGDOptimizer, Tensor, util} from '../deeplearnjs'; +import {NDArrayImageVisualizer} from '../ndarray-image-visualizer'; +import {NDArrayLogitsVisualizer} from '../ndarray-logits-visualizer'; +import {PolymerElement, PolymerHTMLElement} from '../polymer-spec'; +import * as xhr_dataset from '../xhr-dataset'; +import {XhrDataset, XhrDatasetConfig} from '../xhr-dataset'; + +import {LayerBuilder, LayerWeightsDict} from './layer_builder'; +import {ModelLayer} from './model-layer'; +import * as model_builder_util from './model_builder_util'; +import {Normalization} from './tensorflow'; + +const DATASETS_CONFIG_JSON = 'model-builder-datasets-config.json'; + +// TODO(nsthorat): Make these parameters in the UI. +const BATCH_SIZE = 64; +const LEARNING_RATE = 0.1; +/** How often to evaluate the model against test data. */ +const EVAL_INTERVAL_MS = 1500; +/** How often to compute the cost. Downloading the cost stalls the GPU. */ +const COST_INTERVAL_MS = 500; +/** How many inference examples to show when evaluating accuracy. */ +const INFERENCE_EXAMPLE_COUNT = 15; +const INFERENCE_IMAGE_SIZE_PX = 100; +/** + * How often to show inference examples. This should be less often than + * EVAL_INTERVAL_MS as we only show inference examples during an eval. + */ +const INFERENCE_EXAMPLE_INTERVAL_MS = 3000; + +// Smoothing factor for the examples/s standalone text statistic. +const EXAMPLE_SEC_STAT_SMOOTHING_FACTOR = .7; + +const TRAIN_TEST_RATIO = 5 / 6; + +const IMAGE_DATA_INDEX = 0; +const LABEL_DATA_INDEX = 1; + +// tslint:disable-next-line:variable-name +export let ModelBuilderPolymer = PolymerElement({ + is: 'model-builder', + properties: { + inputShapeDisplay: String, + isValid: Boolean, + inferencesPerSec: Number, + inferenceDuration: Number, + examplesTrained: Number, + examplesPerSec: Number, + totalTimeSec: String, + applicationState: Number, + modelInitialized: Boolean, + showTrainStats: Boolean, + datasetDownloaded: Boolean, + datasetNames: Array, + selectedDatasetName: String, + modelNames: Array, + selectedModelName: String, + selectedNormalizationOption: + {type: Number, value: Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE}, + // Stats + showDatasetStats: Boolean, + statsInputMin: Number, + statsInputMax: Number, + statsInputShapeDisplay: String, + statsLabelShapeDisplay: String, + statsExampleCount: Number, + } +}); + +export enum ApplicationState { + IDLE = 1, + TRAINING = 2 +} + +export class ModelBuilder extends ModelBuilderPolymer { + // Polymer properties. + private isValid: boolean; + private totalTimeSec: string; + private applicationState: ApplicationState; + private modelInitialized: boolean; + private showTrainStats: boolean; + private selectedNormalizationOption: number; + + // Datasets and models. + private graphRunner: GraphRunner; + private graph: Graph; + private session: Session; + private optimizer: Optimizer; + private xTensor: Tensor; + private labelTensor: Tensor; + private costTensor: Tensor; + private accuracyTensor: Tensor; + private predictionTensor: Tensor; + + private datasetDownloaded: boolean; + private datasetNames: string[]; + private selectedDatasetName: string; + private modelNames: string[]; + private selectedModelName: string; + private loadedWeights: LayerWeightsDict[]|null; + private dataSets: {[datasetName: string]: InMemoryDataset}; + private dataSet: InMemoryDataset; + private xhrDatasetConfigs: {[datasetName: string]: XhrDatasetConfig}; + private datasetStats: DataStats[]; + + // Stats. + private showDatasetStats: boolean; + private statsInputRange: string; + private statsInputShapeDisplay: string; + private statsLabelShapeDisplay: string; + private statsExampleCount: number; + + // Charts. + private costChart: Chart; + private accuracyChart: Chart; + private examplesPerSecChart: Chart; + private costChartData: ChartPoint[]; + private accuracyChartData: ChartPoint[]; + private examplesPerSecChartData: ChartPoint[]; + + private trainButton: HTMLButtonElement; + + // Visualizers. + private inputNDArrayVisualizers: NDArrayImageVisualizer[]; + private outputNDArrayVisualizers: NDArrayLogitsVisualizer[]; + + private inputShape: number[]; + private labelShape: number[]; + private examplesPerSec: number; + private examplesTrained: number; + private inferencesPerSec: number; + private inferenceDuration: number; + + private inputLayer: ModelLayer; + private hiddenLayers: ModelLayer[]; + + private layersContainer: HTMLDivElement; + + private math: NDArrayMath; + // Keep one instance of each NDArrayMath so we don't create a user-initiated + // number of NDArrayMathGPU's. + private mathGPU: NDArrayMathGPU; + private mathCPU: NDArrayMathCPU; + + ready() { + this.mathGPU = new NDArrayMathGPU(); + this.mathCPU = new NDArrayMathCPU(); + this.math = this.mathGPU; + + const eventObserver: GraphRunnerEventObserver = { + batchesTrainedCallback: (batchesTrained: number) => + this.displayBatchesTrained(batchesTrained), + avgCostCallback: (avgCost: Scalar) => this.displayCost(avgCost), + metricCallback: (metric: Scalar) => this.displayAccuracy(metric), + inferenceExamplesCallback: + (inputFeeds: FeedEntry[][], inferenceOutputs: NDArray[]) => + this.displayInferenceExamplesOutput(inputFeeds, inferenceOutputs), + inferenceExamplesPerSecCallback: (examplesPerSec: number) => + this.displayInferenceExamplesPerSec(examplesPerSec), + trainExamplesPerSecCallback: (examplesPerSec: number) => + this.displayExamplesPerSec(examplesPerSec), + totalTimeCallback: (totalTimeSec: number) => this.totalTimeSec = + totalTimeSec.toFixed(1), + }; + this.graphRunner = new GraphRunner(this.math, this.session, eventObserver); + this.optimizer = new SGDOptimizer(LEARNING_RATE); + + // Set up datasets. + this.populateDatasets(); + + this.querySelector('#dataset-dropdown .dropdown-content')!.addEventListener( + // tslint:disable-next-line:no-any + 'iron-activate', (event: any) => { + // Update the dataset. + const datasetName = event.detail.selected; + this.updateSelectedDataset(datasetName); + + // TODO(nsthorat): Remember the last model used for each dataset. + this.removeAllLayers(); + }); + this.querySelector('#model-dropdown .dropdown-content')!.addEventListener( + // tslint:disable-next-line:no-any + 'iron-activate', (event: any) => { + // Update the model. + const modelName = event.detail.selected; + this.updateSelectedModel(modelName); + }); + + { + const normalizationDropdown = + this.querySelector('#normalization-dropdown .dropdown-content')!; + // tslint:disable-next-line:no-any + normalizationDropdown.addEventListener('iron-activate', (event: any) => { + const selectedNormalizationOption = event.detail.selected; + this.applyNormalization(selectedNormalizationOption); + this.setupDatasetStats(); + }); + } + + this.applicationState = ApplicationState.IDLE; + this.loadedWeights = null; + this.modelInitialized = false; + this.showTrainStats = false; + this.showDatasetStats = false; + + const addButton = this.querySelector('#add-layer')!; + addButton.addEventListener('click', () => this.addLayer()); + + const downloadModelButton = this.querySelector('#download-model')!; + downloadModelButton.addEventListener('click', () => this.downloadModel()); + const uploadModelButton = this.querySelector('#upload-model')!; + uploadModelButton.addEventListener('click', () => this.uploadModel()); + this.setupUploadModelButton(); + + const uploadWeightsButton = this.querySelector('#upload-weights')!; + uploadWeightsButton.addEventListener('click', () => this.uploadWeights()); + this.setupUploadWeightsButton(); + + const stopButton = this.querySelector('#stop')!; + stopButton.addEventListener('click', () => { + this.applicationState = ApplicationState.IDLE; + this.graphRunner.stopTraining(); + }); + + this.trainButton = this.querySelector('#train') as HTMLButtonElement; + this.trainButton.addEventListener('click', () => { + this.createModel(); + this.startTraining(); + }); + + this.querySelector( + '#environment-toggle')!.addEventListener('change', (event) => { + // tslint:disable-next-line:no-any + this.math = (event.target as any).active ? this.mathGPU : this.mathCPU; + this.graphRunner.setMath(this.math); + }); + + this.hiddenLayers = []; + this.examplesPerSec = 0; + this.inferencesPerSec = 0; + } + + isTraining(applicationState: ApplicationState): boolean { + return applicationState === ApplicationState.TRAINING; + } + + isIdle(applicationState: ApplicationState): boolean { + return applicationState === ApplicationState.IDLE; + } + + private getTestData(): NDArray[][] { + const data = this.dataSet.getData(); + if (data == null) { + return null; + } + const [images, labels] = this.dataSet.getData() as [NDArray[], NDArray[]]; + + const start = Math.floor(TRAIN_TEST_RATIO * images.length); + + return [images.slice(start), labels.slice(start)]; + } + + private getTrainingData(): NDArray[][] { + const [images, labels] = this.dataSet.getData() as [NDArray[], NDArray[]]; + + const end = Math.floor(TRAIN_TEST_RATIO * images.length); + + return [images.slice(0, end), labels.slice(0, end)]; + } + + private startInference() { + const testData = this.getTestData(); + if (testData == null) { + // Dataset not ready yet. + return; + } + if (this.isValid && (testData != null)) { + const inferenceShuffledInputProviderGenerator = + new InCPUMemoryShuffledInputProviderBuilder(testData); + const [inferenceInputProvider, inferenceLabelProvider] = + inferenceShuffledInputProviderGenerator.getInputProviders(); + + const inferenceFeeds = [ + {tensor: this.xTensor, data: inferenceInputProvider}, + {tensor: this.labelTensor, data: inferenceLabelProvider} + ]; + + this.graphRunner.infer( + this.predictionTensor, inferenceFeeds, INFERENCE_EXAMPLE_INTERVAL_MS, + INFERENCE_EXAMPLE_COUNT); + } + } + + private startTraining() { + const trainingData = this.getTrainingData(); + const testData = this.getTestData(); + + if (this.isValid && (trainingData != null) && (testData != null)) { + this.recreateCharts(); + this.graphRunner.resetStatistics(); + + const trainingShuffledInputProviderGenerator = + new InCPUMemoryShuffledInputProviderBuilder(trainingData); + const [trainInputProvider, trainLabelProvider] = + trainingShuffledInputProviderGenerator.getInputProviders(); + + const trainFeeds = [ + {tensor: this.xTensor, data: trainInputProvider}, + {tensor: this.labelTensor, data: trainLabelProvider} + ]; + + const accuracyShuffledInputProviderGenerator = + new InCPUMemoryShuffledInputProviderBuilder(testData); + const [accuracyInputProvider, accuracyLabelProvider] = + accuracyShuffledInputProviderGenerator.getInputProviders(); + + const accuracyFeeds = [ + {tensor: this.xTensor, data: accuracyInputProvider}, + {tensor: this.labelTensor, data: accuracyLabelProvider} + ]; + + this.graphRunner.train( + this.costTensor, trainFeeds, BATCH_SIZE, this.optimizer, + undefined /** numBatches */, this.accuracyTensor, accuracyFeeds, + BATCH_SIZE, MetricReduction.MEAN, EVAL_INTERVAL_MS, COST_INTERVAL_MS); + + this.showTrainStats = true; + this.applicationState = ApplicationState.TRAINING; + } + } + + private createModel() { + if (this.session != null) { + this.session.dispose(); + } + + this.modelInitialized = false; + if (this.isValid === false) { + return; + } + + this.graph = new Graph(); + const g = this.graph; + this.xTensor = g.placeholder('input', this.inputShape); + this.labelTensor = g.placeholder('label', this.labelShape); + + let network = this.xTensor; + + for (let i = 0; i < this.hiddenLayers.length; i++) { + let weights: LayerWeightsDict|null = null; + if (this.loadedWeights != null) { + weights = this.loadedWeights[i]; + } + network = this.hiddenLayers[i].addLayer(g, network, i, weights); + } + this.predictionTensor = network; + this.costTensor = + g.softmaxCrossEntropyCost(this.predictionTensor, this.labelTensor); + this.accuracyTensor = + g.argmaxEquals(this.predictionTensor, this.labelTensor); + + this.loadedWeights = null; + + this.session = new Session(g, this.math); + this.graphRunner.setSession(this.session); + + this.startInference(); + + this.modelInitialized = true; + } + + private populateDatasets() { + this.dataSets = {}; + xhr_dataset.getXhrDatasetConfig(DATASETS_CONFIG_JSON) + .then( + xhrDatasetConfigs => { + for (const datasetName in xhrDatasetConfigs) { + if (xhrDatasetConfigs.hasOwnProperty(datasetName)) { + this.dataSets[datasetName] = + new XhrDataset(xhrDatasetConfigs[datasetName]); + } + } + this.datasetNames = Object.keys(this.dataSets); + this.selectedDatasetName = this.datasetNames[0]; + this.xhrDatasetConfigs = xhrDatasetConfigs; + this.updateSelectedDataset(this.datasetNames[0]); + }, + error => { + throw new Error('Dataset config could not be loaded: ' + error); + }); + } + + private updateSelectedDataset(datasetName: string) { + this.graphRunner.stopTraining(); + this.graphRunner.stopInferring(); + + if (this.dataSet != null) { + this.dataSet.dispose(); + } + + this.selectedDatasetName = datasetName; + this.dataSet = this.dataSets[datasetName]; + this.datasetDownloaded = false; + this.showDatasetStats = false; + + this.dataSet.fetchData().then(() => { + this.datasetDownloaded = true; + this.applyNormalization(this.selectedNormalizationOption); + this.setupDatasetStats(); + if (this.isValid) { + this.createModel(); + this.startInference(); + } + }); + // Get prebuilt models. + this.populateModelDropdown(); + + this.inputShape = this.dataSet.getDataShape(IMAGE_DATA_INDEX); + this.labelShape = this.dataSet.getDataShape(LABEL_DATA_INDEX); + + this.layersContainer = + this.querySelector('#hidden-layers') as HTMLDivElement; + + this.inputLayer = this.querySelector('#input-layer') as ModelLayer; + this.inputLayer.outputShapeDisplay = + model_builder_util.getDisplayShape(this.inputShape); + + const labelShapeDisplay = + model_builder_util.getDisplayShape(this.labelShape); + const costLayer = this.querySelector('#cost-layer') as ModelLayer; + costLayer.inputShapeDisplay = labelShapeDisplay; + costLayer.outputShapeDisplay = labelShapeDisplay; + + const outputLayer = this.querySelector('#output-layer') as ModelLayer; + outputLayer.inputShapeDisplay = labelShapeDisplay; + + // Setup the inference example container. + // TODO(nsthorat): Generalize this. + const inferenceContainer = + this.querySelector('#inference-container') as HTMLElement; + inferenceContainer.innerHTML = ''; + this.inputNDArrayVisualizers = []; + this.outputNDArrayVisualizers = []; + for (let i = 0; i < INFERENCE_EXAMPLE_COUNT; i++) { + const inferenceExampleElement = document.createElement('div'); + inferenceExampleElement.className = 'inference-example'; + + // Set up the input visualizer. + const ndarrayImageVisualizer = + document.createElement('ndarray-image-visualizer') as + NDArrayImageVisualizer; + ndarrayImageVisualizer.setShape(this.inputShape); + ndarrayImageVisualizer.setSize( + INFERENCE_IMAGE_SIZE_PX, INFERENCE_IMAGE_SIZE_PX); + this.inputNDArrayVisualizers.push(ndarrayImageVisualizer); + inferenceExampleElement.appendChild(ndarrayImageVisualizer); + + // Set up the output ndarray visualizer. + const ndarrayLogitsVisualizer = + document.createElement('ndarray-logits-visualizer') as + NDArrayLogitsVisualizer; + ndarrayLogitsVisualizer.initialize( + INFERENCE_IMAGE_SIZE_PX, INFERENCE_IMAGE_SIZE_PX); + this.outputNDArrayVisualizers.push(ndarrayLogitsVisualizer); + inferenceExampleElement.appendChild(ndarrayLogitsVisualizer); + + inferenceContainer.appendChild(inferenceExampleElement); + } + } + + private populateModelDropdown() { + const modelNames = ['Custom']; + + const modelConfigs = + this.xhrDatasetConfigs[this.selectedDatasetName].modelConfigs; + for (const modelName in modelConfigs) { + if (modelConfigs.hasOwnProperty(modelName)) { + modelNames.push(modelName); + } + } + + this.modelNames = modelNames; + this.selectedModelName = modelNames[modelNames.length - 1]; + this.updateSelectedModel(this.selectedModelName); + } + + private updateSelectedModel(modelName: string) { + this.removeAllLayers(); + if (modelName === 'Custom') { + // TODO(nsthorat): Remember the custom layers. + return; + } + + this.loadModelFromPath(this.xhrDatasetConfigs[this.selectedDatasetName] + .modelConfigs[modelName] + .path); + } + + private loadModelFromPath(modelPath: string) { + const xhr = new XMLHttpRequest(); + xhr.open('GET', modelPath); + + xhr.onload = () => { + this.loadModelFromJson(xhr.responseText); + }; + xhr.onerror = (error) => { + throw new Error( + 'Model could not be fetched from ' + modelPath + ': ' + error); + }; + xhr.send(); + } + + private setupDatasetStats() { + this.datasetStats = this.dataSet.getStats(); + this.statsExampleCount = this.datasetStats[IMAGE_DATA_INDEX].exampleCount; + this.statsInputRange = '[' + this.datasetStats[IMAGE_DATA_INDEX].inputMin + + ', ' + this.datasetStats[IMAGE_DATA_INDEX].inputMax + ']'; + this.statsInputShapeDisplay = model_builder_util.getDisplayShape( + this.datasetStats[IMAGE_DATA_INDEX].shape); + this.statsLabelShapeDisplay = model_builder_util.getDisplayShape( + this.datasetStats[LABEL_DATA_INDEX].shape); + this.showDatasetStats = true; + } + + private applyNormalization(selectedNormalizationOption: number) { + switch (selectedNormalizationOption) { + case Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE: { + this.dataSet.normalizeWithinBounds(IMAGE_DATA_INDEX, -1, 1); + break; + } + case Normalization.NORMALIZATION_ZERO_TO_ONE: { + this.dataSet.normalizeWithinBounds(IMAGE_DATA_INDEX, 0, 1); + break; + } + case Normalization.NORMALIZATION_NONE: { + this.dataSet.removeNormalization(IMAGE_DATA_INDEX); + break; + } + default: { throw new Error('Normalization option must be 0, 1, or 2'); } + } + this.setupDatasetStats(); + } + + private recreateCharts() { + this.costChartData = []; + if (this.costChart != null) { + this.costChart.destroy(); + } + this.costChart = + this.createChart('cost-chart', 'Cost', this.costChartData, 0); + + if (this.accuracyChart != null) { + this.accuracyChart.destroy(); + } + this.accuracyChartData = []; + this.accuracyChart = this.createChart( + 'accuracy-chart', 'Accuracy', this.accuracyChartData, 0, 100); + + if (this.examplesPerSecChart != null) { + this.examplesPerSecChart.destroy(); + } + this.examplesPerSecChartData = []; + this.examplesPerSecChart = this.createChart( + 'examplespersec-chart', 'Examples/sec', this.examplesPerSecChartData, + 0); + } + + private createChart( + canvasId: string, label: string, data: ChartData[], min?: number, + max?: number): Chart { + const context = (document.getElementById(canvasId) as HTMLCanvasElement) + .getContext('2d') as CanvasRenderingContext2D; + return new Chart(context, { + type: 'line', + data: { + datasets: [{ + data, + fill: false, + label, + pointRadius: 0, + borderColor: 'rgba(75,192,192,1)', + borderWidth: 1, + lineTension: 0, + pointHitRadius: 8 + }] + }, + options: { + animation: {duration: 0}, + responsive: false, + scales: { + xAxes: [{type: 'linear', position: 'bottom'}], + yAxes: [{ + ticks: { + max, + min, + } + }] + } + } + }); + } + + displayBatchesTrained(totalBatchesTrained: number) { + this.examplesTrained = BATCH_SIZE * totalBatchesTrained; + } + + displayCost(avgCost: Scalar) { + this.costChartData.push( + {x: this.graphRunner.getTotalBatchesTrained(), y: avgCost.get()}); + this.costChart.update(); + } + + displayAccuracy(accuracy: Scalar) { + this.accuracyChartData.push({ + x: this.graphRunner.getTotalBatchesTrained(), + y: accuracy.get() * 100 + }); + this.accuracyChart.update(); + } + + displayInferenceExamplesPerSec(examplesPerSec: number) { + this.inferencesPerSec = + this.smoothExamplesPerSec(this.inferencesPerSec, examplesPerSec); + this.inferenceDuration = Number((1000 / examplesPerSec).toPrecision(3)); + } + + displayExamplesPerSec(examplesPerSec: number) { + this.examplesPerSecChartData.push( + {x: this.graphRunner.getTotalBatchesTrained(), y: examplesPerSec}); + this.examplesPerSecChart.update(); + this.examplesPerSec = + this.smoothExamplesPerSec(this.examplesPerSec, examplesPerSec); + } + + private smoothExamplesPerSec( + lastExamplesPerSec: number, nextExamplesPerSec: number): number { + return Number((EXAMPLE_SEC_STAT_SMOOTHING_FACTOR * lastExamplesPerSec + + (1 - EXAMPLE_SEC_STAT_SMOOTHING_FACTOR) * nextExamplesPerSec) + .toPrecision(3)); + } + + displayInferenceExamplesOutput( + inputFeeds: FeedEntry[][], inferenceOutputs: NDArray[]) { + let images: Array3D[] = []; + const logits: Array1D[] = []; + const labels: Array1D[] = []; + for (let i = 0; i < inputFeeds.length; i++) { + images.push(inputFeeds[i][IMAGE_DATA_INDEX].data as Array3D); + labels.push(inputFeeds[i][LABEL_DATA_INDEX].data as Array1D); + logits.push(inferenceOutputs[i] as Array1D); + } + + images = + this.dataSet.unnormalizeExamples(images, IMAGE_DATA_INDEX) as Array3D[]; + + // Draw the images. + for (let i = 0; i < inputFeeds.length; i++) { + this.inputNDArrayVisualizers[i].saveImageDataFromNDArray(images[i]); + } + + // Draw the logits. + for (let i = 0; i < inputFeeds.length; i++) { + const softmaxLogits = this.math.softmax(logits[i]); + + this.outputNDArrayVisualizers[i].drawLogits( + softmaxLogits, labels[i], + this.xhrDatasetConfigs[this.selectedDatasetName].labelClassNames); + this.inputNDArrayVisualizers[i].draw(); + + softmaxLogits.dispose(); + } + } + + addLayer(): ModelLayer { + const modelLayer = document.createElement('model-layer') as ModelLayer; + modelLayer.className = 'layer'; + this.layersContainer.appendChild(modelLayer); + + const lastHiddenLayer = this.hiddenLayers[this.hiddenLayers.length - 1]; + const lastOutputShape = lastHiddenLayer != null ? + lastHiddenLayer.getOutputShape() : + this.inputShape; + this.hiddenLayers.push(modelLayer); + modelLayer.initialize(this, lastOutputShape); + return modelLayer; + } + + removeLayer(modelLayer: ModelLayer) { + this.layersContainer.removeChild(modelLayer); + this.hiddenLayers.splice(this.hiddenLayers.indexOf(modelLayer), 1); + this.layerParamChanged(); + } + + private removeAllLayers() { + for (let i = 0; i < this.hiddenLayers.length; i++) { + this.layersContainer.removeChild(this.hiddenLayers[i]); + } + this.hiddenLayers = []; + this.layerParamChanged(); + } + + private validateModel() { + let valid = true; + for (let i = 0; i < this.hiddenLayers.length; ++i) { + valid = valid && this.hiddenLayers[i].isValid(); + } + if (this.hiddenLayers.length > 0) { + const lastLayer = this.hiddenLayers[this.hiddenLayers.length - 1]; + valid = valid && + util.arraysEqual(this.labelShape, lastLayer.getOutputShape()); + } + this.isValid = valid && (this.hiddenLayers.length > 0); + } + + layerParamChanged() { + // Go through each of the model layers and propagate shapes. + let lastOutputShape = this.inputShape; + for (let i = 0; i < this.hiddenLayers.length; i++) { + lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape); + } + this.validateModel(); + + if (this.isValid) { + this.createModel(); + this.startInference(); + } + } + + private downloadModel() { + const modelJson = this.getModelAsJson(); + const blob = new Blob([modelJson], {type: 'text/json'}); + const textFile = window.URL.createObjectURL(blob); + + // Force a download. + const a = document.createElement('a'); + document.body.appendChild(a); + a.style.display = 'none'; + a.href = textFile; + // tslint:disable-next-line:no-any + (a as any).download = this.selectedDatasetName + '_model'; + a.click(); + + document.body.removeChild(a); + window.URL.revokeObjectURL(textFile); + } + + private uploadModel() { + (this.querySelector('#model-file') as HTMLInputElement).click(); + } + + private setupUploadModelButton() { + // Show and setup the load view button. + const fileInput = this.querySelector('#model-file') as HTMLInputElement; + fileInput.addEventListener('change', event => { + const file = fileInput.files![0]; + // Clear out the value of the file chooser. This ensures that if the user + // selects the same file, we'll re-read it. + fileInput.value = ''; + const fileReader = new FileReader(); + fileReader.onload = (evt) => { + this.removeAllLayers(); + const modelJson: string = fileReader.result; + this.loadModelFromJson(modelJson); + }; + fileReader.readAsText(file); + }); + } + + private getModelAsJson(): string { + const layerBuilders: LayerBuilder[] = []; + for (let i = 0; i < this.hiddenLayers.length; i++) { + layerBuilders.push(this.hiddenLayers[i].layerBuilder); + } + return JSON.stringify(layerBuilders); + } + + private loadModelFromJson(modelJson: string) { + let lastOutputShape = this.inputShape; + + const layerBuilders = JSON.parse(modelJson) as LayerBuilder[]; + for (let i = 0; i < layerBuilders.length; i++) { + const modelLayer = this.addLayer(); + modelLayer.loadParamsFromLayerBuilder(lastOutputShape, layerBuilders[i]); + lastOutputShape = this.hiddenLayers[i].setInputShape(lastOutputShape); + } + this.validateModel(); + } + + private uploadWeights() { + (this.querySelector('#weights-file') as HTMLInputElement).click(); + } + + private setupUploadWeightsButton() { + // Show and setup the load view button. + const fileInput = this.querySelector('#weights-file') as HTMLInputElement; + fileInput.addEventListener('change', event => { + const file = fileInput.files![0]; + // Clear out the value of the file chooser. This ensures that if the user + // selects the same file, we'll re-read it. + fileInput.value = ''; + const fileReader = new FileReader(); + fileReader.onload = (evt) => { + const weightsJson: string = fileReader.result; + this.loadWeightsFromJson(weightsJson); + this.createModel(); + this.startInference(); + }; + fileReader.readAsText(file); + }); + } + + private loadWeightsFromJson(weightsJson: string) { + this.loadedWeights = JSON.parse(weightsJson) as LayerWeightsDict[]; + } +} + +document.registerElement(ModelBuilder.prototype.is, ModelBuilder); diff --git a/demos/model-builder/model-layer.html b/demos/model-builder/model-layer.html new file mode 100644 index 0000000000..34c8fceb57 --- /dev/null +++ b/demos/model-builder/model-layer.html @@ -0,0 +1,135 @@ + + + + + + + + + + + diff --git a/demos/model-builder/model-layer.ts b/demos/model-builder/model-layer.ts new file mode 100644 index 0000000000..6080c84518 --- /dev/null +++ b/demos/model-builder/model-layer.ts @@ -0,0 +1,190 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Graph, Tensor} from '../deeplearnjs'; +// tslint:disable-next-line:no-unused-variable +import {PolymerElement, PolymerHTMLElement} from '../polymer-spec'; + +import * as layer_builder from './layer_builder'; +import {LayerBuilder, LayerName, LayerWeightsDict} from './layer_builder'; +import {ModelBuilder} from './model-builder'; +import * as model_builder_util from './model_builder_util'; + +// tslint:disable-next-line:variable-name +export let ModelLayerPolymer = PolymerElement({ + is: 'model-layer', + properties: { + layerName: String, + inputShapeDisplay: String, + outputShapeDisplay: String, + isStatic: {type: Boolean, value: false}, + layerNames: Array, + selectedLayerName: String, + hasError: {type: Boolean, value: false}, + errorMessages: Array, + } +}); + +export class ModelLayer extends ModelLayerPolymer { + // Polymer properties. + inputShapeDisplay: string; + outputShapeDisplay: string; + private layerNames: LayerName[]; + private selectedLayerName: LayerName; + private hasError: boolean; + private errorMessages: string[]; + + private modelBuilder: ModelBuilder; + layerBuilder: LayerBuilder; + private inputShape: number[]; + private outputShape: number[]; + + private paramContainer: HTMLDivElement; + + initialize(modelBuilder: ModelBuilder, inputShape: number[]) { + this.modelBuilder = modelBuilder; + this.paramContainer = + this.querySelector('.param-container') as HTMLDivElement; + this.layerNames = [ + 'Fully connected', 'ReLU', 'Convolution', 'Max pool', 'Reshape', 'Flatten' + ]; + this.inputShape = inputShape; + this.buildParamsUI('Fully connected', this.inputShape); + + this.querySelector('.dropdown-content')!.addEventListener( + // tslint:disable-next-line:no-any + 'iron-activate', (event: any) => { + this.buildParamsUI( + event.detail.selected as LayerName, this.inputShape); + }); + + this.querySelector('#remove-layer')!.addEventListener('click', (event) => { + modelBuilder.removeLayer(this); + }); + } + + setInputShape(shape: number[]): number[] { + this.inputShape = shape; + this.inputShapeDisplay = + model_builder_util.getDisplayShape(this.inputShape); + + const errors: string[] = []; + const validationErrors = this.layerBuilder.validate(this.inputShape); + if (validationErrors != null) { + for (let i = 0; i < validationErrors.length; i++) { + errors.push('Error: ' + validationErrors[i]); + } + } + + try { + this.outputShape = this.layerBuilder.getOutputShape(this.inputShape); + } catch (e) { + errors.push(e); + } + this.outputShapeDisplay = + model_builder_util.getDisplayShape(this.outputShape); + + if (errors.length > 0) { + this.hasError = true; + this.errorMessages = errors; + } else { + this.hasError = false; + this.errorMessages = []; + } + + return this.outputShape; + } + + isValid(): boolean { + return !this.hasError; + } + + getOutputShape(): number[] { + return this.outputShape; + } + + addLayer( + g: Graph, network: Tensor, index: number, + weights: LayerWeightsDict|null): Tensor { + return this.layerBuilder.addLayer( + g, network, this.inputShape, index, weights); + } + + /** + * Build parameters for the UI for a given op type. This is called when the + * op is added, and when the op type changes. + */ + buildParamsUI( + layerName: LayerName, inputShape: number[], + layerBuilderJson?: LayerBuilder) { + this.selectedLayerName = layerName; + + this.layerBuilder = + layer_builder.getLayerBuilder(layerName, layerBuilderJson); + + // Clear any existing parameters. + this.paramContainer.innerHTML = ''; + + // Add all the parameters to the UI. + const layerParams = this.layerBuilder.getLayerParams(); + for (let i = 0; i < layerParams.length; i++) { + const initialValue = layerBuilderJson != null ? + layerParams[i].getValue() : + layerParams[i].initialValue(inputShape); + this.addParamField( + layerParams[i].label, initialValue, layerParams[i].setValue, + layerParams[i].type, layerParams[i].min, layerParams[i].max); + } + this.modelBuilder.layerParamChanged(); + } + + loadParamsFromLayerBuilder( + inputShape: number[], layerBuilderJson: LayerBuilder) { + this.buildParamsUI( + layerBuilderJson.layerName, inputShape, layerBuilderJson); + } + + private addParamField( + label: string, initialValue: number|string, + setValue: (value: number|string) => void, type: 'number'|'text', + min?: number, max?: number) { + const input = document.createElement('paper-input'); + input.setAttribute('always-float-label', 'true'); + input.setAttribute('label', label); + input.setAttribute('value', '' + initialValue); + input.setAttribute('type', type); + if (type === 'number') { + input.setAttribute('min', '' + min); + input.setAttribute('max', '' + max); + } + input.className = 'param-input'; + this.paramContainer.appendChild(input); + + // Update the parent when this changes. + input.addEventListener('input', (event) => { + if (type === 'number') { + // tslint:disable-next-line:no-any + setValue((event.target as any).valueAsNumber as number); + } else { + // tslint:disable-next-line:no-any + setValue((event.target as any).value as string); + } + this.modelBuilder.layerParamChanged(); + }); + setValue(initialValue); + } +} + +document.registerElement(ModelLayer.prototype.is, ModelLayer); diff --git a/demos/model-builder/model_builder_util.ts b/demos/model-builder/model_builder_util.ts new file mode 100644 index 0000000000..d2598c4031 --- /dev/null +++ b/demos/model-builder/model_builder_util.ts @@ -0,0 +1,18 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export function getDisplayShape(shape: number[]) { + return '[' + shape + ']'; +} \ No newline at end of file diff --git a/demos/model-builder/tensorflow.ts b/demos/model-builder/tensorflow.ts new file mode 100644 index 0000000000..11a02bb8d2 --- /dev/null +++ b/demos/model-builder/tensorflow.ts @@ -0,0 +1,200 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Convolution2DLayerBuilder, LayerBuilder, MaxPoolLayerBuilder} from './layer_builder'; + +export enum Normalization { + NORMALIZATION_NEGATIVE_ONE_TO_ONE, + NORMALIZATION_ZERO_TO_ONE, + NORMALIZATION_NONE +} + +export function generatePython( + datasetName: string, normalizationStrategy: number, inputShape: number[], + modelLayers: LayerBuilder[]): string { + const loadData = generateLoadData(datasetName, normalizationStrategy); + const buildModel = generateBuildModel(inputShape, modelLayers); + const captureWeights = generateCaptureWeights(modelLayers); + return [loadData, buildModel, captureWeights].join('\n\n'); +} + +function generateLoadData( + datasetName: string, normalizationStrategy: number): string { + let loadFunction: string; + switch (datasetName) { + case 'CIFAR 10': { + loadFunction = 'cifar10'; + break; + } + case 'MNIST': { + loadFunction = 'mnist'; + break; + } + default: { + throw new Error('datasetName must be \'CIFAR 10\' or \'MNIST\''); + } + } + + let normString: string; + switch (normalizationStrategy) { + case Normalization.NORMALIZATION_NEGATIVE_ONE_TO_ONE: { + normString = 'NORMALIZATION_NEGATIVE_ONE_TO_ONE'; + break; + } + case Normalization.NORMALIZATION_ZERO_TO_ONE: { + normString = 'NORMALIZATION_ZERO_TO_ONE'; + break; + } + case Normalization.NORMALIZATION_NONE: { + normString = 'NORMALIZATION_NONE'; + break; + } + default: { throw new Error('invalid normalizationStrategy value'); } + } + + return `def load_data(): + return learnjs_colab.load_${loadFunction}(learnjs_colab.${normString}) +`; +} + +function generateBuildModelLayer( + layerIndex: number, inputShape: number[], layer: LayerBuilder): string { + let src = ''; + const W = 'W_' + layerIndex; + const b = 'b_' + layerIndex; + const outputShape = layer.getOutputShape(inputShape); + switch (layer.layerName) { + case 'Fully connected': { + const shape = [inputShape[0], outputShape].join(', '); + + src = ` ${W} = tf.Variable(tf.truncated_normal([${shape}], + stddev = 1.0 / math.sqrt(${outputShape[0]}))) + ${b} = tf.Variable(tf.truncated_normal([${outputShape[0]}], stddev = 0.1)) + layers.append({ 'x': layers[-1]['y'], + 'W': ${W}, + 'b': ${b}, + 'y': tf.add(tf.matmul(layers[-1]['y'], ${W}), ${b}) })`; + break; + } + + case 'ReLU': { + src = ` layers.append({ 'x': layers[-1]['y'], + 'y': tf.nn.relu(layers[-1]['y']) })`; + break; + } + + case 'Convolution': { + const conv = layer as Convolution2DLayerBuilder; + const f = conv.fieldSize; + const d1 = inputShape[inputShape.length - 1]; + const d2 = outputShape[outputShape.length - 1]; + const wShape = '[' + f + ', ' + f + ', ' + d1 + ', ' + d2 + ']'; + const stride = '[1, ' + conv.stride + ', ' + conv.stride + ', 1]'; + src = ` ${W} = tf.Variable(tf.truncated_normal(${wShape}, stddev = 0.1)) + ${b} = tf.Variable(tf.truncated_normal([${d2}], stddev = 0.1)) + layers.append({ 'x': layers[-1]['y'], + 'W': ${W}, + 'b': ${b}, + 'y': tf.add(tf.nn.conv2d(layers[-1]['y'], + ${W}, + strides = ${stride}, + padding = 'SAME'), ${b}) })`; + break; + } + + case 'Max pool': { + const mp = layer as MaxPoolLayerBuilder; + const field = '[1, ' + mp.fieldSize + ', ' + mp.fieldSize + ', 1]'; + const stride = '[1, ' + mp.stride + ', ' + mp.stride + ', 1]'; + src = ` layers.append({ 'x': layers[-1]['y'], + 'y': tf.nn.max_pool(layers[-1]['y'], + ${field}, + ${stride}, + padding = 'SAME') })`; + break; + } + + case 'Reshape': { + break; + } + + case 'Flatten': { + src = ` layers.append({ 'x': layers[-1]['y'], + 'y': tf.reshape(layers[-1]['y'], [-1, ${outputShape[0]}]) })`; + break; + } + + default: { + throw new Error('unknown layer type \'' + layer.layerName + '\''); + } + } + + return src; +} + +function generateBuildModel( + inputShape: number[], modelLayers: LayerBuilder[]): string { + const inputShapeStr = inputShape.join(', '); + const sources: string[] = []; + + sources.push(`def build_model(): + layers = [] + + layers.append({ 'y': tf.placeholder(tf.float32, [None, ${inputShapeStr}]), + 'y_label': tf.placeholder(tf.float32, [None, 10]) })`); + + for (let i = 0; i < modelLayers.length; ++i) { + sources.push(generateBuildModelLayer(i + 1, inputShape, modelLayers[i])); + inputShape = modelLayers[i].getOutputShape(inputShape); + } + + sources.push(' return layers\n'); + return sources.join('\n\n'); +} + +function generateCaptureWeights(modelLayers: LayerBuilder[]): string { + const sources: string[] = []; + sources.push(`def capture_weights(): + weights = []`); + + for (let i = 0; i < modelLayers.length; ++i) { + const layer = modelLayers[i]; + const index = i + 1; + let src = ''; + const W = '\'W\': model[' + index + '][\'W\']'; + const b = '\'b\': model[' + index + '][\'b\']'; + switch (layer.layerName) { + case 'Fully connected': { + src = ` weights.append({ ${W}.eval().flatten().tolist(), + ${b}.eval().flatten().tolist() })`; + break; + } + + case 'Convolution': { + src = ` weights.append({ ${W}.eval().transpose().flatten().tolist(), + ${b}.eval().flatten().tolist() })`; + break; + } + + default: { src = ' weights.append({})'; } + } + + src += ' # ' + layer.layerName; + sources.push(src); + } + + sources.push(' return weights'); + return sources.join('\n'); +} diff --git a/demos/models/imagenet_classes.ts b/demos/models/imagenet_classes.ts new file mode 100644 index 0000000000..b9c88a399e --- /dev/null +++ b/demos/models/imagenet_classes.ts @@ -0,0 +1,1034 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export const IMAGENET_CLASSES: {[key: number]: string} = { + 0: 'tench, Tinca tinca', + 1: 'goldfish, Carassius auratus', + 2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias', + 3: 'tiger shark, Galeocerdo cuvieri', + 4: 'hammerhead, hammerhead shark', + 5: 'electric ray, crampfish, numbfish, torpedo', + 6: 'stingray', + 7: 'cock', + 8: 'hen', + 9: 'ostrich, Struthio camelus', + 10: 'brambling, Fringilla montifringilla', + 11: 'goldfinch, Carduelis carduelis', + 12: 'house finch, linnet, Carpodacus mexicanus', + 13: 'junco, snowbird', + 14: 'indigo bunting, indigo finch, indigo bird, Passerina cyanea', + 15: 'robin, American robin, Turdus migratorius', + 16: 'bulbul', + 17: 'jay', + 18: 'magpie', + 19: 'chickadee', + 20: 'water ouzel, dipper', + 21: 'kite', + 22: 'bald eagle, American eagle, Haliaeetus leucocephalus', + 23: 'vulture', + 24: 'great grey owl, great gray owl, Strix nebulosa', + 25: 'European fire salamander, Salamandra salamandra', + 26: 'common newt, Triturus vulgaris', + 27: 'eft', + 28: 'spotted salamander, Ambystoma maculatum', + 29: 'axolotl, mud puppy, Ambystoma mexicanum', + 30: 'bullfrog, Rana catesbeiana', + 31: 'tree frog, tree-frog', + 32: 'tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui', + 33: 'loggerhead, loggerhead turtle, Caretta caretta', + 34: 'leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea', + 35: 'mud turtle', + 36: 'terrapin', + 37: 'box turtle, box tortoise', + 38: 'banded gecko', + 39: 'common iguana, iguana, Iguana iguana', + 40: 'American chameleon, anole, Anolis carolinensis', + 41: 'whiptail, whiptail lizard', + 42: 'agama', + 43: 'frilled lizard, Chlamydosaurus kingi', + 44: 'alligator lizard', + 45: 'Gila monster, Heloderma suspectum', + 46: 'green lizard, Lacerta viridis', + 47: 'African chameleon, Chamaeleo chamaeleon', + 48: 'Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis', + 49: 'African crocodile, Nile crocodile, Crocodylus niloticus', + 50: 'American alligator, Alligator mississipiensis', + 51: 'triceratops', + 52: 'thunder snake, worm snake, Carphophis amoenus', + 53: 'ringneck snake, ring-necked snake, ring snake', + 54: 'hognose snake, puff adder, sand viper', + 55: 'green snake, grass snake', + 56: 'king snake, kingsnake', + 57: 'garter snake, grass snake', + 58: 'water snake', + 59: 'vine snake', + 60: 'night snake, Hypsiglena torquata', + 61: 'boa constrictor, Constrictor constrictor', + 62: 'rock python, rock snake, Python sebae', + 63: 'Indian cobra, Naja naja', + 64: 'green mamba', + 65: 'sea snake', + 66: 'horned viper, cerastes, sand viper, horned asp, Cerastes cornutus', + 67: 'diamondback, diamondback rattlesnake, Crotalus adamanteus', + 68: 'sidewinder, horned rattlesnake, Crotalus cerastes', + 69: 'trilobite', + 70: 'harvestman, daddy longlegs, Phalangium opilio', + 71: 'scorpion', + 72: 'black and gold garden spider, Argiope aurantia', + 73: 'barn spider, Araneus cavaticus', + 74: 'garden spider, Aranea diademata', + 75: 'black widow, Latrodectus mactans', + 76: 'tarantula', + 77: 'wolf spider, hunting spider', + 78: 'tick', + 79: 'centipede', + 80: 'black grouse', + 81: 'ptarmigan', + 82: 'ruffed grouse, partridge, Bonasa umbellus', + 83: 'prairie chicken, prairie grouse, prairie fowl', + 84: 'peacock', + 85: 'quail', + 86: 'partridge', + 87: 'African grey, African gray, Psittacus erithacus', + 88: 'macaw', + 89: 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita', + 90: 'lorikeet', + 91: 'coucal', + 92: 'bee eater', + 93: 'hornbill', + 94: 'hummingbird', + 95: 'jacamar', + 96: 'toucan', + 97: 'drake', + 98: 'red-breasted merganser, Mergus serrator', + 99: 'goose', + 100: 'black swan, Cygnus atratus', + 101: 'tusker', + 102: 'echidna, spiny anteater, anteater', + 103: + 'platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus', + 104: 'wallaby, brush kangaroo', + 105: 'koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus', + 106: 'wombat', + 107: 'jelly fish', + 108: 'sea anemone, anemone', + 109: 'brain coral', + 110: 'flatworm, platyhelminth', + 111: 'nematode, nematode worm, roundworm', + 112: 'conch', + 113: 'snail', + 114: 'slug', + 115: 'sea slug, nudibranch', + 116: 'chiton, coat-of-mail shell, sea cradle, polyplacophore', + 117: 'chambered nautilus, pearly nautilus, nautilus', + 118: 'Dungeness crab, Cancer magister', + 119: 'rock crab, Cancer irroratus', + 120: 'fiddler crab', + 121: + 'king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica', + 122: 'American lobster, Northern lobster, Maine lobster, Homarus americanus', + 123: + 'spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish', + 124: 'crayfish, crawfish, crawdad, crawdaddy', + 125: 'hermit crab', + 126: 'isopod', + 127: 'white stork, Ciconia ciconia', + 128: 'black stork, Ciconia nigra', + 129: 'spoonbill', + 130: 'flamingo', + 131: 'little blue heron, Egretta caerulea', + 132: 'American egret, great white heron, Egretta albus', + 133: 'bittern', + 134: 'crane', + 135: 'limpkin, Aramus pictus', + 136: 'European gallinule, Porphyrio porphyrio', + 137: 'American coot, marsh hen, mud hen, water hen, Fulica americana', + 138: 'bustard', + 139: 'ruddy turnstone, Arenaria interpres', + 140: 'red-backed sandpiper, dunlin, Erolia alpina', + 141: 'redshank, Tringa totanus', + 142: 'dowitcher', + 143: 'oystercatcher, oyster catcher', + 144: 'pelican', + 145: 'king penguin, Aptenodytes patagonica', + 146: 'albatross, mollymawk', + 147: + 'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus', + 148: 'killer whale, killer, orca, grampus, sea wolf, Orcinus orca', + 149: 'dugong, Dugong dugon', + 150: 'sea lion', + 151: 'Chihuahua', + 152: 'Japanese spaniel', + 153: 'Maltese dog, Maltese terrier, Maltese', + 154: 'Pekinese, Pekingese, Peke', + 155: 'Shih-Tzu', + 156: 'Blenheim spaniel', + 157: 'papillon', + 158: 'toy terrier', + 159: 'Rhodesian ridgeback', + 160: 'Afghan hound, Afghan', + 161: 'basset, basset hound', + 162: 'beagle', + 163: 'bloodhound, sleuthhound', + 164: 'bluetick', + 165: 'black-and-tan coonhound', + 166: 'Walker hound, Walker foxhound', + 167: 'English foxhound', + 168: 'redbone', + 169: 'borzoi, Russian wolfhound', + 170: 'Irish wolfhound', + 171: 'Italian greyhound', + 172: 'whippet', + 173: 'Ibizan hound, Ibizan Podenco', + 174: 'Norwegian elkhound, elkhound', + 175: 'otterhound, otter hound', + 176: 'Saluki, gazelle hound', + 177: 'Scottish deerhound, deerhound', + 178: 'Weimaraner', + 179: 'Staffordshire bullterrier, Staffordshire bull terrier', + 180: + 'American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier', + 181: 'Bedlington terrier', + 182: 'Border terrier', + 183: 'Kerry blue terrier', + 184: 'Irish terrier', + 185: 'Norfolk terrier', + 186: 'Norwich terrier', + 187: 'Yorkshire terrier', + 188: 'wire-haired fox terrier', + 189: 'Lakeland terrier', + 190: 'Sealyham terrier, Sealyham', + 191: 'Airedale, Airedale terrier', + 192: 'cairn, cairn terrier', + 193: 'Australian terrier', + 194: 'Dandie Dinmont, Dandie Dinmont terrier', + 195: 'Boston bull, Boston terrier', + 196: 'miniature schnauzer', + 197: 'giant schnauzer', + 198: 'standard schnauzer', + 199: 'Scotch terrier, Scottish terrier, Scottie', + 200: 'Tibetan terrier, chrysanthemum dog', + 201: 'silky terrier, Sydney silky', + 202: 'soft-coated wheaten terrier', + 203: 'West Highland white terrier', + 204: 'Lhasa, Lhasa apso', + 205: 'flat-coated retriever', + 206: 'curly-coated retriever', + 207: 'golden retriever', + 208: 'Labrador retriever', + 209: 'Chesapeake Bay retriever', + 210: 'German short-haired pointer', + 211: 'vizsla, Hungarian pointer', + 212: 'English setter', + 213: 'Irish setter, red setter', + 214: 'Gordon setter', + 215: 'Brittany spaniel', + 216: 'clumber, clumber spaniel', + 217: 'English springer, English springer spaniel', + 218: 'Welsh springer spaniel', + 219: 'cocker spaniel, English cocker spaniel, cocker', + 220: 'Sussex spaniel', + 221: 'Irish water spaniel', + 222: 'kuvasz', + 223: 'schipperke', + 224: 'groenendael', + 225: 'malinois', + 226: 'briard', + 227: 'kelpie', + 228: 'komondor', + 229: 'Old English sheepdog, bobtail', + 230: 'Shetland sheepdog, Shetland sheep dog, Shetland', + 231: 'collie', + 232: 'Border collie', + 233: 'Bouvier des Flandres, Bouviers des Flandres', + 234: 'Rottweiler', + 235: 'German shepherd, German shepherd dog, German police dog, alsatian', + 236: 'Doberman, Doberman pinscher', + 237: 'miniature pinscher', + 238: 'Greater Swiss Mountain dog', + 239: 'Bernese mountain dog', + 240: 'Appenzeller', + 241: 'EntleBucher', + 242: 'boxer', + 243: 'bull mastiff', + 244: 'Tibetan mastiff', + 245: 'French bulldog', + 246: 'Great Dane', + 247: 'Saint Bernard, St Bernard', + 248: 'Eskimo dog, husky', + 249: 'malamute, malemute, Alaskan malamute', + 250: 'Siberian husky', + 251: 'dalmatian, coach dog, carriage dog', + 252: 'affenpinscher, monkey pinscher, monkey dog', + 253: 'basenji', + 254: 'pug, pug-dog', + 255: 'Leonberg', + 256: 'Newfoundland, Newfoundland dog', + 257: 'Great Pyrenees', + 258: 'Samoyed, Samoyede', + 259: 'Pomeranian', + 260: 'chow, chow chow', + 261: 'keeshond', + 262: 'Brabancon griffon', + 263: 'Pembroke, Pembroke Welsh corgi', + 264: 'Cardigan, Cardigan Welsh corgi', + 265: 'toy poodle', + 266: 'miniature poodle', + 267: 'standard poodle', + 268: 'Mexican hairless', + 269: 'timber wolf, grey wolf, gray wolf, Canis lupus', + 270: 'white wolf, Arctic wolf, Canis lupus tundrarum', + 271: 'red wolf, maned wolf, Canis rufus, Canis niger', + 272: 'coyote, prairie wolf, brush wolf, Canis latrans', + 273: 'dingo, warrigal, warragal, Canis dingo', + 274: 'dhole, Cuon alpinus', + 275: 'African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus', + 276: 'hyena, hyaena', + 277: 'red fox, Vulpes vulpes', + 278: 'kit fox, Vulpes macrotis', + 279: 'Arctic fox, white fox, Alopex lagopus', + 280: 'grey fox, gray fox, Urocyon cinereoargenteus', + 281: 'tabby, tabby cat', + 282: 'tiger cat', + 283: 'Persian cat', + 284: 'Siamese cat, Siamese', + 285: 'Egyptian cat', + 286: + 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor', + 287: 'lynx, catamount', + 288: 'leopard, Panthera pardus', + 289: 'snow leopard, ounce, Panthera uncia', + 290: 'jaguar, panther, Panthera onca, Felis onca', + 291: 'lion, king of beasts, Panthera leo', + 292: 'tiger, Panthera tigris', + 293: 'cheetah, chetah, Acinonyx jubatus', + 294: 'brown bear, bruin, Ursus arctos', + 295: 'American black bear, black bear, Ursus americanus, Euarctos americanus', + 296: 'ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus', + 297: 'sloth bear, Melursus ursinus, Ursus ursinus', + 298: 'mongoose', + 299: 'meerkat, mierkat', + 300: 'tiger beetle', + 301: 'ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle', + 302: 'ground beetle, carabid beetle', + 303: 'long-horned beetle, longicorn, longicorn beetle', + 304: 'leaf beetle, chrysomelid', + 305: 'dung beetle', + 306: 'rhinoceros beetle', + 307: 'weevil', + 308: 'fly', + 309: 'bee', + 310: 'ant, emmet, pismire', + 311: 'grasshopper, hopper', + 312: 'cricket', + 313: 'walking stick, walkingstick, stick insect', + 314: 'cockroach, roach', + 315: 'mantis, mantid', + 316: 'cicada, cicala', + 317: 'leafhopper', + 318: 'lacewing, lacewing fly', + 319: + 'dragonfly, darning needle, devil\'s darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk', + 320: 'damselfly', + 321: 'admiral', + 322: 'ringlet, ringlet butterfly', + 323: 'monarch, monarch butterfly, milkweed butterfly, Danaus plexippus', + 324: 'cabbage butterfly', + 325: 'sulphur butterfly, sulfur butterfly', + 326: 'lycaenid, lycaenid butterfly', + 327: 'starfish, sea star', + 328: 'sea urchin', + 329: 'sea cucumber, holothurian', + 330: 'wood rabbit, cottontail, cottontail rabbit', + 331: 'hare', + 332: 'Angora, Angora rabbit', + 333: 'hamster', + 334: 'porcupine, hedgehog', + 335: 'fox squirrel, eastern fox squirrel, Sciurus niger', + 336: 'marmot', + 337: 'beaver', + 338: 'guinea pig, Cavia cobaya', + 339: 'sorrel', + 340: 'zebra', + 341: 'hog, pig, grunter, squealer, Sus scrofa', + 342: 'wild boar, boar, Sus scrofa', + 343: 'warthog', + 344: 'hippopotamus, hippo, river horse, Hippopotamus amphibius', + 345: 'ox', + 346: 'water buffalo, water ox, Asiatic buffalo, Bubalus bubalis', + 347: 'bison', + 348: 'ram, tup', + 349: + 'bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis', + 350: 'ibex, Capra ibex', + 351: 'hartebeest', + 352: 'impala, Aepyceros melampus', + 353: 'gazelle', + 354: 'Arabian camel, dromedary, Camelus dromedarius', + 355: 'llama', + 356: 'weasel', + 357: 'mink', + 358: 'polecat, fitch, foulmart, foumart, Mustela putorius', + 359: 'black-footed ferret, ferret, Mustela nigripes', + 360: 'otter', + 361: 'skunk, polecat, wood pussy', + 362: 'badger', + 363: 'armadillo', + 364: 'three-toed sloth, ai, Bradypus tridactylus', + 365: 'orangutan, orang, orangutang, Pongo pygmaeus', + 366: 'gorilla, Gorilla gorilla', + 367: 'chimpanzee, chimp, Pan troglodytes', + 368: 'gibbon, Hylobates lar', + 369: 'siamang, Hylobates syndactylus, Symphalangus syndactylus', + 370: 'guenon, guenon monkey', + 371: 'patas, hussar monkey, Erythrocebus patas', + 372: 'baboon', + 373: 'macaque', + 374: 'langur', + 375: 'colobus, colobus monkey', + 376: 'proboscis monkey, Nasalis larvatus', + 377: 'marmoset', + 378: 'capuchin, ringtail, Cebus capucinus', + 379: 'howler monkey, howler', + 380: 'titi, titi monkey', + 381: 'spider monkey, Ateles geoffroyi', + 382: 'squirrel monkey, Saimiri sciureus', + 383: 'Madagascar cat, ring-tailed lemur, Lemur catta', + 384: 'indri, indris, Indri indri, Indri brevicaudatus', + 385: 'Indian elephant, Elephas maximus', + 386: 'African elephant, Loxodonta africana', + 387: 'lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens', + 388: 'giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca', + 389: 'barracouta, snoek', + 390: 'eel', + 391: + 'coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch', + 392: 'rock beauty, Holocanthus tricolor', + 393: 'anemone fish', + 394: 'sturgeon', + 395: 'gar, garfish, garpike, billfish, Lepisosteus osseus', + 396: 'lionfish', + 397: 'puffer, pufferfish, blowfish, globefish', + 398: 'abacus', + 399: 'abaya', + 400: 'academic gown, academic robe, judge\'s robe', + 401: 'accordion, piano accordion, squeeze box', + 402: 'acoustic guitar', + 403: 'aircraft carrier, carrier, flattop, attack aircraft carrier', + 404: 'airliner', + 405: 'airship, dirigible', + 406: 'altar', + 407: 'ambulance', + 408: 'amphibian, amphibious vehicle', + 409: 'analog clock', + 410: 'apiary, bee house', + 411: 'apron', + 412: + 'ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin', + 413: 'assault rifle, assault gun', + 414: 'backpack, back pack, knapsack, packsack, rucksack, haversack', + 415: 'bakery, bakeshop, bakehouse', + 416: 'balance beam, beam', + 417: 'balloon', + 418: 'ballpoint, ballpoint pen, ballpen, Biro', + 419: 'Band Aid', + 420: 'banjo', + 421: 'bannister, banister, balustrade, balusters, handrail', + 422: 'barbell', + 423: 'barber chair', + 424: 'barbershop', + 425: 'barn', + 426: 'barometer', + 427: 'barrel, cask', + 428: 'barrow, garden cart, lawn cart, wheelbarrow', + 429: 'baseball', + 430: 'basketball', + 431: 'bassinet', + 432: 'bassoon', + 433: 'bathing cap, swimming cap', + 434: 'bath towel', + 435: 'bathtub, bathing tub, bath, tub', + 436: + 'beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon', + 437: 'beacon, lighthouse, beacon light, pharos', + 438: 'beaker', + 439: 'bearskin, busby, shako', + 440: 'beer bottle', + 441: 'beer glass', + 442: 'bell cote, bell cot', + 443: 'bib', + 444: 'bicycle-built-for-two, tandem bicycle, tandem', + 445: 'bikini, two-piece', + 446: 'binder, ring-binder', + 447: 'binoculars, field glasses, opera glasses', + 448: 'birdhouse', + 449: 'boathouse', + 450: 'bobsled, bobsleigh, bob', + 451: 'bolo tie, bolo, bola tie, bola', + 452: 'bonnet, poke bonnet', + 453: 'bookcase', + 454: 'bookshop, bookstore, bookstall', + 455: 'bottlecap', + 456: 'bow', + 457: 'bow tie, bow-tie, bowtie', + 458: 'brass, memorial tablet, plaque', + 459: 'brassiere, bra, bandeau', + 460: 'breakwater, groin, groyne, mole, bulwark, seawall, jetty', + 461: 'breastplate, aegis, egis', + 462: 'broom', + 463: 'bucket, pail', + 464: 'buckle', + 465: 'bulletproof vest', + 466: 'bullet train, bullet', + 467: 'butcher shop, meat market', + 468: 'cab, hack, taxi, taxicab', + 469: 'caldron, cauldron', + 470: 'candle, taper, wax light', + 471: 'cannon', + 472: 'canoe', + 473: 'can opener, tin opener', + 474: 'cardigan', + 475: 'car mirror', + 476: 'carousel, carrousel, merry-go-round, roundabout, whirligig', + 477: 'carpenter\'s kit, tool kit', + 478: 'carton', + 479: 'car wheel', + 480: + 'cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM', + 481: 'cassette', + 482: 'cassette player', + 483: 'castle', + 484: 'catamaran', + 485: 'CD player', + 486: 'cello, violoncello', + 487: 'cellular telephone, cellular phone, cellphone, cell, mobile phone', + 488: 'chain', + 489: 'chainlink fence', + 490: + 'chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour', + 491: 'chain saw, chainsaw', + 492: 'chest', + 493: 'chiffonier, commode', + 494: 'chime, bell, gong', + 495: 'china cabinet, china closet', + 496: 'Christmas stocking', + 497: 'church, church building', + 498: 'cinema, movie theater, movie theatre, movie house, picture palace', + 499: 'cleaver, meat cleaver, chopper', + 500: 'cliff dwelling', + 501: 'cloak', + 502: 'clog, geta, patten, sabot', + 503: 'cocktail shaker', + 504: 'coffee mug', + 505: 'coffeepot', + 506: 'coil, spiral, volute, whorl, helix', + 507: 'combination lock', + 508: 'computer keyboard, keypad', + 509: 'confectionery, confectionary, candy store', + 510: 'container ship, containership, container vessel', + 511: 'convertible', + 512: 'corkscrew, bottle screw', + 513: 'cornet, horn, trumpet, trump', + 514: 'cowboy boot', + 515: 'cowboy hat, ten-gallon hat', + 516: 'cradle', + 517: 'crane', + 518: 'crash helmet', + 519: 'crate', + 520: 'crib, cot', + 521: 'Crock Pot', + 522: 'croquet ball', + 523: 'crutch', + 524: 'cuirass', + 525: 'dam, dike, dyke', + 526: 'desk', + 527: 'desktop computer', + 528: 'dial telephone, dial phone', + 529: 'diaper, nappy, napkin', + 530: 'digital clock', + 531: 'digital watch', + 532: 'dining table, board', + 533: 'dishrag, dishcloth', + 534: 'dishwasher, dish washer, dishwashing machine', + 535: 'disk brake, disc brake', + 536: 'dock, dockage, docking facility', + 537: 'dogsled, dog sled, dog sleigh', + 538: 'dome', + 539: 'doormat, welcome mat', + 540: 'drilling platform, offshore rig', + 541: 'drum, membranophone, tympan', + 542: 'drumstick', + 543: 'dumbbell', + 544: 'Dutch oven', + 545: 'electric fan, blower', + 546: 'electric guitar', + 547: 'electric locomotive', + 548: 'entertainment center', + 549: 'envelope', + 550: 'espresso maker', + 551: 'face powder', + 552: 'feather boa, boa', + 553: 'file, file cabinet, filing cabinet', + 554: 'fireboat', + 555: 'fire engine, fire truck', + 556: 'fire screen, fireguard', + 557: 'flagpole, flagstaff', + 558: 'flute, transverse flute', + 559: 'folding chair', + 560: 'football helmet', + 561: 'forklift', + 562: 'fountain', + 563: 'fountain pen', + 564: 'four-poster', + 565: 'freight car', + 566: 'French horn, horn', + 567: 'frying pan, frypan, skillet', + 568: 'fur coat', + 569: 'garbage truck, dustcart', + 570: 'gasmask, respirator, gas helmet', + 571: 'gas pump, gasoline pump, petrol pump, island dispenser', + 572: 'goblet', + 573: 'go-kart', + 574: 'golf ball', + 575: 'golfcart, golf cart', + 576: 'gondola', + 577: 'gong, tam-tam', + 578: 'gown', + 579: 'grand piano, grand', + 580: 'greenhouse, nursery, glasshouse', + 581: 'grille, radiator grille', + 582: 'grocery store, grocery, food market, market', + 583: 'guillotine', + 584: 'hair slide', + 585: 'hair spray', + 586: 'half track', + 587: 'hammer', + 588: 'hamper', + 589: 'hand blower, blow dryer, blow drier, hair dryer, hair drier', + 590: 'hand-held computer, hand-held microcomputer', + 591: 'handkerchief, hankie, hanky, hankey', + 592: 'hard disc, hard disk, fixed disk', + 593: 'harmonica, mouth organ, harp, mouth harp', + 594: 'harp', + 595: 'harvester, reaper', + 596: 'hatchet', + 597: 'holster', + 598: 'home theater, home theatre', + 599: 'honeycomb', + 600: 'hook, claw', + 601: 'hoopskirt, crinoline', + 602: 'horizontal bar, high bar', + 603: 'horse cart, horse-cart', + 604: 'hourglass', + 605: 'iPod', + 606: 'iron, smoothing iron', + 607: 'jack-o\'-lantern', + 608: 'jean, blue jean, denim', + 609: 'jeep, landrover', + 610: 'jersey, T-shirt, tee shirt', + 611: 'jigsaw puzzle', + 612: 'jinrikisha, ricksha, rickshaw', + 613: 'joystick', + 614: 'kimono', + 615: 'knee pad', + 616: 'knot', + 617: 'lab coat, laboratory coat', + 618: 'ladle', + 619: 'lampshade, lamp shade', + 620: 'laptop, laptop computer', + 621: 'lawn mower, mower', + 622: 'lens cap, lens cover', + 623: 'letter opener, paper knife, paperknife', + 624: 'library', + 625: 'lifeboat', + 626: 'lighter, light, igniter, ignitor', + 627: 'limousine, limo', + 628: 'liner, ocean liner', + 629: 'lipstick, lip rouge', + 630: 'Loafer', + 631: 'lotion', + 632: 'loudspeaker, speaker, speaker unit, loudspeaker system, speaker system', + 633: 'loupe, jeweler\'s loupe', + 634: 'lumbermill, sawmill', + 635: 'magnetic compass', + 636: 'mailbag, postbag', + 637: 'mailbox, letter box', + 638: 'maillot', + 639: 'maillot, tank suit', + 640: 'manhole cover', + 641: 'maraca', + 642: 'marimba, xylophone', + 643: 'mask', + 644: 'matchstick', + 645: 'maypole', + 646: 'maze, labyrinth', + 647: 'measuring cup', + 648: 'medicine chest, medicine cabinet', + 649: 'megalith, megalithic structure', + 650: 'microphone, mike', + 651: 'microwave, microwave oven', + 652: 'military uniform', + 653: 'milk can', + 654: 'minibus', + 655: 'miniskirt, mini', + 656: 'minivan', + 657: 'missile', + 658: 'mitten', + 659: 'mixing bowl', + 660: 'mobile home, manufactured home', + 661: 'Model T', + 662: 'modem', + 663: 'monastery', + 664: 'monitor', + 665: 'moped', + 666: 'mortar', + 667: 'mortarboard', + 668: 'mosque', + 669: 'mosquito net', + 670: 'motor scooter, scooter', + 671: 'mountain bike, all-terrain bike, off-roader', + 672: 'mountain tent', + 673: 'mouse, computer mouse', + 674: 'mousetrap', + 675: 'moving van', + 676: 'muzzle', + 677: 'nail', + 678: 'neck brace', + 679: 'necklace', + 680: 'nipple', + 681: 'notebook, notebook computer', + 682: 'obelisk', + 683: 'oboe, hautboy, hautbois', + 684: 'ocarina, sweet potato', + 685: 'odometer, hodometer, mileometer, milometer', + 686: 'oil filter', + 687: 'organ, pipe organ', + 688: 'oscilloscope, scope, cathode-ray oscilloscope, CRO', + 689: 'overskirt', + 690: 'oxcart', + 691: 'oxygen mask', + 692: 'packet', + 693: 'paddle, boat paddle', + 694: 'paddlewheel, paddle wheel', + 695: 'padlock', + 696: 'paintbrush', + 697: 'pajama, pyjama, pj\'s, jammies', + 698: 'palace', + 699: 'panpipe, pandean pipe, syrinx', + 700: 'paper towel', + 701: 'parachute, chute', + 702: 'parallel bars, bars', + 703: 'park bench', + 704: 'parking meter', + 705: 'passenger car, coach, carriage', + 706: 'patio, terrace', + 707: 'pay-phone, pay-station', + 708: 'pedestal, plinth, footstall', + 709: 'pencil box, pencil case', + 710: 'pencil sharpener', + 711: 'perfume, essence', + 712: 'Petri dish', + 713: 'photocopier', + 714: 'pick, plectrum, plectron', + 715: 'pickelhaube', + 716: 'picket fence, paling', + 717: 'pickup, pickup truck', + 718: 'pier', + 719: 'piggy bank, penny bank', + 720: 'pill bottle', + 721: 'pillow', + 722: 'ping-pong ball', + 723: 'pinwheel', + 724: 'pirate, pirate ship', + 725: 'pitcher, ewer', + 726: 'plane, carpenter\'s plane, woodworking plane', + 727: 'planetarium', + 728: 'plastic bag', + 729: 'plate rack', + 730: 'plow, plough', + 731: 'plunger, plumber\'s helper', + 732: 'Polaroid camera, Polaroid Land camera', + 733: 'pole', + 734: + 'police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria', + 735: 'poncho', + 736: 'pool table, billiard table, snooker table', + 737: 'pop bottle, soda bottle', + 738: 'pot, flowerpot', + 739: 'potter\'s wheel', + 740: 'power drill', + 741: 'prayer rug, prayer mat', + 742: 'printer', + 743: 'prison, prison house', + 744: 'projectile, missile', + 745: 'projector', + 746: 'puck, hockey puck', + 747: 'punching bag, punch bag, punching ball, punchball', + 748: 'purse', + 749: 'quill, quill pen', + 750: 'quilt, comforter, comfort, puff', + 751: 'racer, race car, racing car', + 752: 'racket, racquet', + 753: 'radiator', + 754: 'radio, wireless', + 755: 'radio telescope, radio reflector', + 756: 'rain barrel', + 757: 'recreational vehicle, RV, R.V.', + 758: 'reel', + 759: 'reflex camera', + 760: 'refrigerator, icebox', + 761: 'remote control, remote', + 762: 'restaurant, eating house, eating place, eatery', + 763: 'revolver, six-gun, six-shooter', + 764: 'rifle', + 765: 'rocking chair, rocker', + 766: 'rotisserie', + 767: 'rubber eraser, rubber, pencil eraser', + 768: 'rugby ball', + 769: 'rule, ruler', + 770: 'running shoe', + 771: 'safe', + 772: 'safety pin', + 773: 'saltshaker, salt shaker', + 774: 'sandal', + 775: 'sarong', + 776: 'sax, saxophone', + 777: 'scabbard', + 778: 'scale, weighing machine', + 779: 'school bus', + 780: 'schooner', + 781: 'scoreboard', + 782: 'screen, CRT screen', + 783: 'screw', + 784: 'screwdriver', + 785: 'seat belt, seatbelt', + 786: 'sewing machine', + 787: 'shield, buckler', + 788: 'shoe shop, shoe-shop, shoe store', + 789: 'shoji', + 790: 'shopping basket', + 791: 'shopping cart', + 792: 'shovel', + 793: 'shower cap', + 794: 'shower curtain', + 795: 'ski', + 796: 'ski mask', + 797: 'sleeping bag', + 798: 'slide rule, slipstick', + 799: 'sliding door', + 800: 'slot, one-armed bandit', + 801: 'snorkel', + 802: 'snowmobile', + 803: 'snowplow, snowplough', + 804: 'soap dispenser', + 805: 'soccer ball', + 806: 'sock', + 807: 'solar dish, solar collector, solar furnace', + 808: 'sombrero', + 809: 'soup bowl', + 810: 'space bar', + 811: 'space heater', + 812: 'space shuttle', + 813: 'spatula', + 814: 'speedboat', + 815: 'spider web, spider\'s web', + 816: 'spindle', + 817: 'sports car, sport car', + 818: 'spotlight, spot', + 819: 'stage', + 820: 'steam locomotive', + 821: 'steel arch bridge', + 822: 'steel drum', + 823: 'stethoscope', + 824: 'stole', + 825: 'stone wall', + 826: 'stopwatch, stop watch', + 827: 'stove', + 828: 'strainer', + 829: 'streetcar, tram, tramcar, trolley, trolley car', + 830: 'stretcher', + 831: 'studio couch, day bed', + 832: 'stupa, tope', + 833: 'submarine, pigboat, sub, U-boat', + 834: 'suit, suit of clothes', + 835: 'sundial', + 836: 'sunglass', + 837: 'sunglasses, dark glasses, shades', + 838: 'sunscreen, sunblock, sun blocker', + 839: 'suspension bridge', + 840: 'swab, swob, mop', + 841: 'sweatshirt', + 842: 'swimming trunks, bathing trunks', + 843: 'swing', + 844: 'switch, electric switch, electrical switch', + 845: 'syringe', + 846: 'table lamp', + 847: 'tank, army tank, armored combat vehicle, armoured combat vehicle', + 848: 'tape player', + 849: 'teapot', + 850: 'teddy, teddy bear', + 851: 'television, television system', + 852: 'tennis ball', + 853: 'thatch, thatched roof', + 854: 'theater curtain, theatre curtain', + 855: 'thimble', + 856: 'thresher, thrasher, threshing machine', + 857: 'throne', + 858: 'tile roof', + 859: 'toaster', + 860: 'tobacco shop, tobacconist shop, tobacconist', + 861: 'toilet seat', + 862: 'torch', + 863: 'totem pole', + 864: 'tow truck, tow car, wrecker', + 865: 'toyshop', + 866: 'tractor', + 867: + 'trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi', + 868: 'tray', + 869: 'trench coat', + 870: 'tricycle, trike, velocipede', + 871: 'trimaran', + 872: 'tripod', + 873: 'triumphal arch', + 874: 'trolleybus, trolley coach, trackless trolley', + 875: 'trombone', + 876: 'tub, vat', + 877: 'turnstile', + 878: 'typewriter keyboard', + 879: 'umbrella', + 880: 'unicycle, monocycle', + 881: 'upright, upright piano', + 882: 'vacuum, vacuum cleaner', + 883: 'vase', + 884: 'vault', + 885: 'velvet', + 886: 'vending machine', + 887: 'vestment', + 888: 'viaduct', + 889: 'violin, fiddle', + 890: 'volleyball', + 891: 'waffle iron', + 892: 'wall clock', + 893: 'wallet, billfold, notecase, pocketbook', + 894: 'wardrobe, closet, press', + 895: 'warplane, military plane', + 896: 'washbasin, handbasin, washbowl, lavabo, wash-hand basin', + 897: 'washer, automatic washer, washing machine', + 898: 'water bottle', + 899: 'water jug', + 900: 'water tower', + 901: 'whiskey jug', + 902: 'whistle', + 903: 'wig', + 904: 'window screen', + 905: 'window shade', + 906: 'Windsor tie', + 907: 'wine bottle', + 908: 'wing', + 909: 'wok', + 910: 'wooden spoon', + 911: 'wool, woolen, woollen', + 912: 'worm fence, snake fence, snake-rail fence, Virginia fence', + 913: 'wreck', + 914: 'yawl', + 915: 'yurt', + 916: 'web site, website, internet site, site', + 917: 'comic book', + 918: 'crossword puzzle, crossword', + 919: 'street sign', + 920: 'traffic light, traffic signal, stoplight', + 921: 'book jacket, dust cover, dust jacket, dust wrapper', + 922: 'menu', + 923: 'plate', + 924: 'guacamole', + 925: 'consomme', + 926: 'hot pot, hotpot', + 927: 'trifle', + 928: 'ice cream, icecream', + 929: 'ice lolly, lolly, lollipop, popsicle', + 930: 'French loaf', + 931: 'bagel, beigel', + 932: 'pretzel', + 933: 'cheeseburger', + 934: 'hotdog, hot dog, red hot', + 935: 'mashed potato', + 936: 'head cabbage', + 937: 'broccoli', + 938: 'cauliflower', + 939: 'zucchini, courgette', + 940: 'spaghetti squash', + 941: 'acorn squash', + 942: 'butternut squash', + 943: 'cucumber, cuke', + 944: 'artichoke, globe artichoke', + 945: 'bell pepper', + 946: 'cardoon', + 947: 'mushroom', + 948: 'Granny Smith', + 949: 'strawberry', + 950: 'orange', + 951: 'lemon', + 952: 'fig', + 953: 'pineapple, ananas', + 954: 'banana', + 955: 'jackfruit, jak, jack', + 956: 'custard apple', + 957: 'pomegranate', + 958: 'hay', + 959: 'carbonara', + 960: 'chocolate sauce, chocolate syrup', + 961: 'dough', + 962: 'meat loaf, meatloaf', + 963: 'pizza, pizza pie', + 964: 'potpie', + 965: 'burrito', + 966: 'red wine', + 967: 'espresso', + 968: 'cup', + 969: 'eggnog', + 970: 'alp', + 971: 'bubble', + 972: 'cliff, drop, drop-off', + 973: 'coral reef', + 974: 'geyser', + 975: 'lakeside, lakeshore', + 976: 'promontory, headland, head, foreland', + 977: 'sandbar, sand bar', + 978: 'seashore, coast, seacoast, sea-coast', + 979: 'valley, vale', + 980: 'volcano', + 981: 'ballplayer, baseball player', + 982: 'groom, bridegroom', + 983: 'scuba diver', + 984: 'rapeseed', + 985: 'daisy', + 986: + 'yellow lady\'s slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum', + 987: 'corn', + 988: 'acorn', + 989: 'hip, rose hip, rosehip', + 990: 'buckeye, horse chestnut, conker', + 991: 'coral fungus', + 992: 'agaric', + 993: 'gyromitra', + 994: 'stinkhorn, carrion fungus', + 995: 'earthstar', + 996: + 'hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa', + 997: 'bolete', + 998: 'ear, spike, capitulum', + 999: 'toilet tissue, toilet paper, bathroom tissue' +}; diff --git a/demos/models/imagenet_util.ts b/demos/models/imagenet_util.ts new file mode 100644 index 0000000000..ec39bdb3f9 --- /dev/null +++ b/demos/models/imagenet_util.ts @@ -0,0 +1,160 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; +import * as webgl_util from '../../src/math/webgl/webgl_util'; + +/** + * Unpacks an RGB packed image texture into a 2D physical, 3D logical texture + * with the conventional ndarray format and performs the standard imagenet image + * preprocessing. + */ +export function getUnpackAndPreprocessInputShader( + gpgpu: GPGPUContext, inputShapeRC: [number, number]): WebGLProgram { + const fragmentShaderSource = ` + precision highp float; + uniform sampler2D source; + varying vec2 resultUV; + + const vec2 inputShapeCR = vec2(${inputShapeRC[1]}.0, ${inputShapeRC[0]}.0); + + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + vec2 outputCR = floor(gl_FragCoord.xy); + + vec2 sourceCR = vec2(floor(outputCR[0] / 3.0), outputCR[1]); + vec2 sourceUV = (sourceCR + halfCR) / inputShapeCR; + + vec4 sourceValue = texture2D(source, sourceUV) * 255.0; + + float channelValue = 0.0; + int channel = int(mod(outputCR[0], 3.0)); + + if (channel == 0) { + channelValue = sourceValue.r - 103.939; + } else if (channel == 1) { + channelValue = sourceValue.g - 116.779; + } else if (channel == 2) { + channelValue = sourceValue.b - 123.68; + } + + gl_FragColor = vec4(channelValue, 0, 0, 0); + }`; + return gpgpu.createProgram(fragmentShaderSource); +} + +export function preprocessInput( + gpgpu: GPGPUContext, preprocessInputShader: WebGLProgram, + sourceTex: WebGLTexture, resultTex: WebGLTexture, + shapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]); + gpgpu.setProgram(preprocessInputShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} + +/** + * Transposes the depth and the column dimensions of a 3D ndarray represented as + * a 2D texture into a square collage with each channel rendered as a normalized + * grayscale image. The normalization bounds are given as two sample2Ds, + * minValues and maxValues, which give min and max values per channel. These can + * be computed from a max and min pooling layer. + */ +export function getRenderGrayscaleChannelsCollageShader(gpgpu: GPGPUContext): + WebGLProgram { + const fragmentShaderSource = ` + precision highp float; + uniform sampler2D source; + uniform sampler2D minValues; + uniform sampler2D maxValues; + varying vec2 resultUV; + + uniform float imageSize; + uniform float channels; + uniform float imagesPerRow; + uniform vec2 inputShapeCR; + + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + vec2 outputCR = floor(gl_FragCoord.xy); + + float imageRow = floor(outputCR[1] / imageSize); + float imageCol = mod(outputCR[0], imageSize); + + float currentChannel = floor(outputCR[0] / imageSize) + + imageRow * imagesPerRow; + + // When the number of channels is not square, we render white to fill in + // the output texture. + if (currentChannel > channels) { + gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); + return; + } + + float sourceC = channels * imageCol + currentChannel; + float sourceR = mod(outputCR[1], imageSize); + + vec2 sourceUV = (vec2(sourceC, sourceR) + halfCR) / inputShapeCR; + + // Flip the vertical axis of the texture for display since we represent + // image textures as vertically flipped. + float sourceValue = texture2D( + source, vec2(sourceUV.s, 1.0 - sourceUV.t)).r; + + // Normalize the value by sampling the minValues and maxValues texture + // which contain min and max per channel. + vec2 minMaxValuesShapeCR = vec2(channels, 1); + vec2 minMaxValuesCR = vec2(currentChannel, 0); + vec2 minMaxValuesUV = (minMaxValuesCR + halfCR) / minMaxValuesShapeCR; + + float minValue = texture2D(minValues, minMaxValuesUV).r; + float maxValue = texture2D(maxValues, minMaxValuesUV).r; + + float normalizedValue = (sourceValue - minValue) / (maxValue - minValue); + + gl_FragColor = vec4( + normalizedValue, normalizedValue, normalizedValue, 1); + } + `; + return gpgpu.createProgram(fragmentShaderSource); +} + +export function renderGrayscaleChannelsCollage( + gpgpu: GPGPUContext, unpackChannelsShader: WebGLProgram, + sourceTex: WebGLTexture, minValuesTex: WebGLTexture, + maxValuesTex: WebGLTexture, inputShapeRC: [number, number], + imageSize: number, channels: number, textureSize: number, numRows: number) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + gpgpu.setProgram(unpackChannelsShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.setInputMatrixTexture(minValuesTex, 'minValues', 1); + gpgpu.setInputMatrixTexture(maxValuesTex, 'maxValues', 2); + + const imageSizeLoc = gpgpu.getUniformLocation('imageSize'); + gpgpu.gl.uniform1f(imageSizeLoc, imageSize); + + const channelsLoc = gpgpu.getUniformLocation('channels'); + gpgpu.gl.uniform1f(channelsLoc, channels); + + const imagesPerRowLoc = gpgpu.getUniformLocation('imagesPerRow'); + gpgpu.gl.uniform1f(imagesPerRowLoc, Math.floor(textureSize / imageSize)); + + const inputShapeCRLoc = gpgpu.getUniformLocation('inputShapeCR'); + gpgpu.gl.uniform2f(inputShapeCRLoc, inputShapeRC[1], inputShapeRC[0]); + + gpgpu.executeProgram(); +} diff --git a/demos/models/squeezenet.ts b/demos/models/squeezenet.ts new file mode 100644 index 0000000000..382fa5f069 --- /dev/null +++ b/demos/models/squeezenet.ts @@ -0,0 +1,191 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {CheckpointLoader} from '../../src/checkpoint_loader'; +import {NDArrayMathCPU} from '../../src/math/math_cpu'; +import {NDArrayMathGPU} from '../../src/math/math_gpu'; +import {Array1D, Array3D, Array4D, NDArray} from '../../src/math/ndarray'; +import {GPGPUContext} from '../../src/math/webgl/gpgpu_context'; + +import * as imagenet_classes from './imagenet_classes'; +import * as imagenet_util from './imagenet_util'; + +const IMAGE_SIZE = 227; +const NUM_CLASSES = 1000; +const GOOGLE_CLOUD_STORAGE_DIR = + 'https://storage.googleapis.com/learnjs-data/checkpoint_zoo/'; + +export class SqueezeNet { + private variables: {[varName: string]: NDArray}; + + private preprocessInputShader: WebGLShader; + + constructor(private gpgpu: GPGPUContext, private math: NDArrayMathGPU) { + this.preprocessInputShader = + imagenet_util.getUnpackAndPreprocessInputShader( + gpgpu, [IMAGE_SIZE, IMAGE_SIZE]); + } + + /** + * Loads necessary variables for SqueezeNet. Resolves the promise when the + * variables have all been loaded. + */ + loadVariables(): Promise { + return new Promise((resolve, reject) => { + const checkpointLoader = + new CheckpointLoader(GOOGLE_CLOUD_STORAGE_DIR + 'squeezenet1_1/'); + checkpointLoader.getAllVariables().then(variables => { + this.variables = variables; + resolve(); + }); + }); + } + + /** + * Preprocess an RGB color texture before inferring through squeezenet. + * @param rgbTexture The RGB color texture to process into an Array3D. + * @param imageDimensions The 2D dimensions of the image. + */ + preprocessColorTextureToArray3D(rgbTexture: WebGLTexture, imageDimensions: [ + number, number + ]): Array3D { + const preprocessResultShapeRC: [number, number] = + [imageDimensions[0], imageDimensions[0] * 3]; + + const preprocessResultTexture = + this.math.getTextureManager().acquireTexture(preprocessResultShapeRC); + + imagenet_util.preprocessInput( + this.gpgpu, this.preprocessInputShader, rgbTexture, + preprocessResultTexture, preprocessResultShapeRC); + return NDArray.make([imageDimensions[0], imageDimensions[0], 3], { + texture: preprocessResultTexture, + textureShapeRC: preprocessResultShapeRC + }); + } + + /** + * Infer through SqueezeNet, assumes variables have been loaded. This does + * standard ImageNet pre-processing before inferring through the model. This + * method returns named activations as well as pre-softmax logits. The user + * needs to clean up namedActivations after inferring. + * + * @param preprocessedInput preprocessed input Array. + * @return Named activations and the pre-softmax logits. + */ + infer(preprocessedInput: Array3D): + {namedActivations: {[activationName: string]: Array3D}, logits: Array1D} { + const namedActivations: {[key: string]: Array3D} = {}; + + const avgpool10 = this.math.scope((keep) => { + const conv1 = this.math.conv2d( + preprocessedInput, this.variables['conv1_W:0'] as Array4D, + this.variables['conv1_b:0'] as Array1D, 2, 0); + const conv1relu = keep(this.math.relu(conv1)); + namedActivations['conv_1'] = conv1relu; + + const pool1 = keep(this.math.maxPool(conv1relu, 3, 2, 0)); + namedActivations['maxpool_1'] = pool1; + + const fire2 = keep(this.fireModule(pool1, 2)); + namedActivations['fire2'] = fire2; + + const fire3 = keep(this.fireModule(fire2, 3)); + namedActivations['fire3'] = fire3; + + // Because we don't have uneven padding yet, manually pad the ndarray on + // the right. + const fire3Reshape2d = + fire3.as2D(fire3.shape[0], fire3.shape[1] * fire3.shape[2]); + const fire3Sliced2d = this.math.slice2D( + fire3Reshape2d, [0, 0], + [fire3.shape[0] - 1, (fire3.shape[1] - 1) * fire3.shape[2]]); + const fire3Sliced = fire3Sliced2d.as3D( + fire3.shape[0] - 1, fire3.shape[1] - 1, fire3.shape[2]); + const pool2 = keep(this.math.maxPool(fire3Sliced, 3, 2, 0)); + namedActivations['maxpool_2'] = pool2; + + const fire4 = keep(this.fireModule(pool2, 4)); + namedActivations['fire4'] = fire4; + + const fire5 = keep(this.fireModule(fire4, 5)); + namedActivations['fire5'] = fire5; + + const pool3 = keep(this.math.maxPool(fire5, 3, 2, 0)); + namedActivations['maxpool_3'] = pool3; + + const fire6 = keep(this.fireModule(pool3, 6)); + namedActivations['fire6'] = fire6; + + const fire7 = keep(this.fireModule(fire6, 7)); + namedActivations['fire7'] = fire7; + + const fire8 = keep(this.fireModule(fire7, 8)); + namedActivations['fire8'] = fire8; + + const fire9 = keep(this.fireModule(fire8, 9)); + namedActivations['fire9'] = fire9; + + const conv10 = keep(this.math.conv2d( + fire9, this.variables['conv10_W:0'] as Array4D, + this.variables['conv10_b:0'] as Array1D, 1, 0)); + namedActivations['conv10'] = conv10; + + return this.math.avgPool(conv10, conv10.shape[0], 1, 0).as1D(); + }); + + return {namedActivations, logits: avgpool10}; + } + + private fireModule(input: Array3D, fireId: number) { + const y1 = this.math.conv2d( + input, this.variables['fire' + fireId + '/squeeze1x1_W:0'] as Array4D, + this.variables['fire' + fireId + '/squeeze1x1_b:0'] as Array1D, 1, 0); + const y2 = this.math.relu(y1); + const left1 = this.math.conv2d( + y2, this.variables['fire' + fireId + '/expand1x1_W:0'] as Array4D, + this.variables['fire' + fireId + '/expand1x1_b:0'] as Array1D, 1, 0); + const left2 = this.math.relu(left1); + + const right1 = this.math.conv2d( + y2, this.variables['fire' + fireId + '/expand3x3_W:0'] as Array4D, + this.variables['fire' + fireId + '/expand3x3_b:0'] as Array1D, 1, 1); + const right2 = this.math.relu(right1); + + return this.math.concat3D(left2, right2, 2); + } + + /** + * Get the topK classes for pre-softmax logits. Returns a map of className + * to softmax normalized probability. + * + * @param logits Pre-softmax logits array. + * @param topK How many top classes to return. + */ + getTopKClasses(logits: Array1D, topK: number): {[className: string]: number} { + const predictions = this.math.softmax(logits); + const topk = new NDArrayMathCPU().topK(predictions, topK); + const topkIndices = topk.indices.getValues(); + const topkValues = topk.values.getValues(); + + const topClassesToProbability: {[className: string]: number} = {}; + for (let i = 0; i < topkIndices.length; i++) { + topClassesToProbability[imagenet_classes + .IMAGENET_CLASSES[topkIndices[i]]] = + topkValues[i]; + } + return topClassesToProbability; + } +} diff --git a/demos/ndarray-image-visualizer.html b/demos/ndarray-image-visualizer.html new file mode 100644 index 0000000000..304a9b21a4 --- /dev/null +++ b/demos/ndarray-image-visualizer.html @@ -0,0 +1,25 @@ + + + + + + diff --git a/demos/ndarray-image-visualizer.ts b/demos/ndarray-image-visualizer.ts new file mode 100644 index 0000000000..1b3d1abfa2 --- /dev/null +++ b/demos/ndarray-image-visualizer.ts @@ -0,0 +1,90 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +// tslint:disable-next-line:no-unused-variable +import {Array3D} from '../src/math/ndarray'; + +import {PolymerElement, PolymerHTMLElement} from './polymer-spec'; + +// tslint:disable-next-line +export let NDArrayImageVisualizerPolymer = + PolymerElement({is: 'ndarray-image-visualizer', properties: {}}); + +export class NDArrayImageVisualizer extends NDArrayImageVisualizerPolymer { + private canvas: HTMLCanvasElement; + private canvasContext: CanvasRenderingContext2D; + private imageData: ImageData; + + ready() { + this.canvas = this.querySelector('#canvas') as HTMLCanvasElement; + this.canvas.width = 0; + this.canvas.height = 0; + this.canvasContext = + this.canvas.getContext('2d') as CanvasRenderingContext2D; + this.canvas.style.display = 'none'; + } + + setShape(shape: number[]) { + this.canvas.width = shape[1]; + this.canvas.height = shape[0]; + } + + setSize(width: number, height: number) { + this.canvas.style.width = width + 'px'; + this.canvas.style.height = height + 'px'; + } + + saveImageDataFromNDArray(ndarray: Array3D) { + this.imageData = this.canvasContext.createImageData( + this.canvas.width, this.canvas.height); + if (ndarray.shape[2] === 1) { + this.drawGrayscaleImageData(ndarray); + } else if (ndarray.shape[2] === 3) { + this.drawRGBImageData(ndarray); + } + } + + drawRGBImageData(ndarray: Array3D) { + let pixelOffset = 0; + for (let i = 0; i < ndarray.shape[0]; i++) { + for (let j = 0; j < ndarray.shape[1]; j++) { + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 1); + this.imageData.data[pixelOffset++] = ndarray.get(i, j, 2); + this.imageData.data[pixelOffset++] = 255; + } + } + } + + drawGrayscaleImageData(ndarray: Array3D) { + let pixelOffset = 0; + for (let i = 0; i < ndarray.shape[0]; i++) { + for (let j = 0; j < ndarray.shape[1]; j++) { + const value = ndarray.get(i, j, 0); + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = value; + this.imageData.data[pixelOffset++] = 255; + } + } + } + + draw() { + this.canvas.style.display = ''; + this.canvasContext.putImageData(this.imageData, 0, 0); + } +} +document.registerElement( + NDArrayImageVisualizer.prototype.is, NDArrayImageVisualizer); diff --git a/demos/ndarray-logits-visualizer.html b/demos/ndarray-logits-visualizer.html new file mode 100644 index 0000000000..dd444f5240 --- /dev/null +++ b/demos/ndarray-logits-visualizer.html @@ -0,0 +1,45 @@ + + + + + + diff --git a/demos/ndarray-logits-visualizer.ts b/demos/ndarray-logits-visualizer.ts new file mode 100644 index 0000000000..3d4ae145dd --- /dev/null +++ b/demos/ndarray-logits-visualizer.ts @@ -0,0 +1,98 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +// tslint:disable-next-line:no-unused-variable +import {NDArrayMathCPU} from '../src/math/math_cpu'; +import {Array1D} from '../src/math/ndarray'; + +import {PolymerElement, PolymerHTMLElement} from './polymer-spec'; + +const TOP_K = 3; + +// tslint:disable-next-line +export let NDArrayLogitsVisualizerPolymer = + PolymerElement({is: 'ndarray-logits-visualizer', properties: {}}); + +export class NDArrayLogitsVisualizer extends NDArrayLogitsVisualizerPolymer { + private logitLabelElements: HTMLElement[]; + private logitVizElements: HTMLElement[]; + private width: number; + + initialize(width: number, height: number) { + this.width = width; + this.logitLabelElements = []; + this.logitVizElements = []; + const container = this.querySelector('.logits-container') as HTMLElement; + container.style.height = height + 'px'; + + for (let i = 0; i < TOP_K; i++) { + const logitContainer = document.createElement('div'); + logitContainer.style.height = height / (TOP_K + 1) + 'px'; + logitContainer.style.margin = + height / ((2 * TOP_K) * (TOP_K + 1)) + 'px 0'; + logitContainer.className = + 'single-logit-container ndarray-logits-visualizer'; + + const logitLabelElement = document.createElement('div'); + logitLabelElement.className = 'logit-label ndarray-logits-visualizer'; + this.logitLabelElements.push(logitLabelElement); + + const logitVizOuterElement = document.createElement('div'); + logitVizOuterElement.className = + 'logit-viz-outer ndarray-logits-visualizer'; + + const logitVisInnerElement = document.createElement('div'); + logitVisInnerElement.className = + 'logit-viz-inner ndarray-logits-visualizer'; + logitVisInnerElement.innerHTML = ' '; + logitVizOuterElement.appendChild(logitVisInnerElement); + + this.logitVizElements.push(logitVisInnerElement); + + logitContainer.appendChild(logitLabelElement); + logitContainer.appendChild(logitVizOuterElement); + container.appendChild(logitContainer); + } + } + + drawLogits( + predictedLogits: Array1D, labelLogits: Array1D, + labelClassNames?: string[]) { + const mathCpu = new NDArrayMathCPU(); + const labelClass = mathCpu.argMax(labelLogits).get(); + + const topk = mathCpu.topK(predictedLogits, TOP_K); + const topkIndices = topk.indices.getValues(); + const topkValues = topk.values.getValues(); + + for (let i = 0; i < topkIndices.length; i++) { + const index = topkIndices[i]; + this.logitLabelElements[i].innerText = + labelClassNames ? labelClassNames[index] : index + ''; + this.logitLabelElements[i].style.width = + labelClassNames != null ? '100px' : '20px'; + this.logitVizElements[i].style.backgroundColor = index === labelClass ? + 'rgba(120, 185, 50, .84)' : + 'rgba(220, 10, 10, 0.84)'; + this.logitVizElements[i].style.width = + Math.floor(100 * topkValues[i]) + '%'; + this.logitVizElements[i].innerText = + `${(100 * topkValues[i]).toFixed(1)}%`; + } + } +} + +document.registerElement( + NDArrayLogitsVisualizer.prototype.is, NDArrayLogitsVisualizer); diff --git a/demos/nn-art/bundle.js b/demos/nn-art/bundle.js new file mode 100644 index 0000000000..1f8690b70b --- /dev/null +++ b/demos/nn-art/bundle.js @@ -0,0 +1,8264 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o " + inputNumDimensions + ".0) {\n gl_FragColor = vec4(z[1], 0, 0, 0);\n } else {\n gl_FragColor = texture2D(source, resultUV);\n }\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getAddLatentVariablesShader = getAddLatentVariablesShader; +function addLatentVariables(gpgpu, addZShader, sourceTex, resultTex, shapeRowCol, z1, z2) { + gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]); + gpgpu.setProgram(addZShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + var zLoc = gpgpu.getUniformLocation('z'); + gpgpu.gl.uniform2f(zLoc, z1, z2); + gpgpu.executeProgram(); +} +exports.addLatentVariables = addLatentVariables; +function getRenderShader(gpgpu, imageSize) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n uniform int colorMode;\n uniform float outputNumDimensions;\n\n const float destinationSize = " + imageSize + ".0;\n\n const mat3 yuv2rgb = mat3(\n 1, 1, 1,\n 0, -.34413, 1.772,\n 1.402, -.71414, 0);\n\n vec3 hsv2rgb(vec3 c) {\n vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n }\n\n void main() {\n vec2 outputCR = floor(gl_FragCoord.xy);\n float inputC = outputCR.y * destinationSize + outputCR.x;\n float u = (inputC + 0.5) / " + imageSize * imageSize + ".0;\n\n vec4 inputR = vec4(0.0, 1.0, 2.0, 3.0);\n vec4 v = (inputR + 0.5) / outputNumDimensions;\n\n vec4 values = vec4(\n texture2D(source, vec2(u, v[0])).r,\n texture2D(source, vec2(u, v[1])).r,\n texture2D(source, vec2(u, v[2])).r,\n texture2D(source, vec2(u, v[3])).r);\n\n if (colorMode == 0) {\n // RGB\n gl_FragColor = vec4(values.rgb, 1.0);\n } else if (colorMode == 1) {\n // RGBA\n gl_FragColor = values;\n } else if (colorMode == 2) {\n // HSV\n vec3 rgb = hsv2rgb(values.rgb);\n gl_FragColor = vec4(rgb, 1.0);\n } else if (colorMode == 3) {\n // HSVA\n vec3 rgb = hsv2rgb(values.rgb);\n gl_FragColor = vec4(rgb, values[3]);\n } else if (colorMode == 4 || colorMode == 5) {\n // YUV\n values[0] = clamp(values[0], 0.2, 0.8);\n values[1] = values[1] - 0.5;\n values[2] = values[2] - 0.5;\n vec3 rgb = yuv2rgb * values.rgb;\n if (colorMode == 4) {\n // YUV\n gl_FragColor = vec4(rgb, 1.0);\n } else if (colorMode == 5) {\n // YUVA\n gl_FragColor = vec4(rgb, values.a);\n }\n } else if (colorMode == 6) {\n gl_FragColor = vec4(values[0], values[0], values[0], 1.0);\n }\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderShader = getRenderShader; +function render(gpgpu, renderShader, sourceTex, outputNumDimensions, colorMode) { + learnjs_1.webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + var colorModeLoc = gpgpu.getUniformLocation('colorMode'); + gpgpu.gl.uniform1i(colorModeLoc, colorMode); + var outputNumDimensionsLoc = gpgpu.getUniformLocation('outputNumDimensions'); + gpgpu.gl.uniform1f(outputNumDimensionsLoc, outputNumDimensions); + gpgpu.executeProgram(); +} +exports.render = render; +function imagePixelToNormalizedCoord(x, y, imageWidth, imageHeight, zSize) { + var halfWidth = imageWidth * 0.5; + var halfHeight = imageHeight * 0.5; + var normX = (x - halfWidth) / imageWidth; + var normY = (y - halfHeight) / imageHeight; + var r = Math.sqrt(normX * normX + normY * normY); + var result = [normX, normY, r]; + for (var i = 0; i < zSize; i++) { + result.push(0); + } + return result; +} +exports.imagePixelToNormalizedCoord = imagePixelToNormalizedCoord; + +},{"../learnjs":3}],7:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function PolymerElement(spec) { + return Polymer.Class(spec); +} +exports.PolymerElement = PolymerElement; + +},{}],8:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var MANIFEST_FILE = 'manifest.json'; +var CheckpointLoader = (function () { + function CheckpointLoader(urlPath) { + this.urlPath = urlPath; + if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') { + this.urlPath += '/'; + } + } + CheckpointLoader.prototype.loadManifest = function () { + var _this = this; + return new Promise(function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', _this.urlPath + MANIFEST_FILE); + xhr.onload = function () { + _this.checkpointManifest = JSON.parse(xhr.responseText); + resolve(); + }; + xhr.onerror = function (error) { + throw new Error(MANIFEST_FILE + " not found at " + _this.urlPath + ". " + error); + }; + xhr.send(); + }); + }; + CheckpointLoader.prototype.getCheckpointManifest = function () { + var _this = this; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + resolve(_this.checkpointManifest); + }); + }); + } + return new Promise(function (resolve, reject) { + resolve(_this.checkpointManifest); + }); + }; + CheckpointLoader.prototype.getAllVariables = function () { + var _this = this; + if (this.variables != null) { + return new Promise(function (resolve, reject) { + resolve(_this.variables); + }); + } + return new Promise(function (resolve, reject) { + _this.getCheckpointManifest().then(function (checkpointDefinition) { + var variableNames = Object.keys(_this.checkpointManifest); + var variablePromises = []; + for (var i = 0; i < variableNames.length; i++) { + variablePromises.push(_this.getVariable(variableNames[i])); + } + Promise.all(variablePromises).then(function (variables) { + _this.variables = {}; + for (var i = 0; i < variables.length; i++) { + _this.variables[variableNames[i]] = variables[i]; + } + resolve(_this.variables); + }); + }); + }); + }; + CheckpointLoader.prototype.getVariable = function (varName) { + var _this = this; + if (!(varName in this.checkpointManifest)) { + throw new Error('Cannot load non-existant variable ' + varName); + } + var variableRequestPromiseMethod = function (resolve, reject) { + var xhr = new XMLHttpRequest(); + xhr.responseType = 'arraybuffer'; + var fname = _this.checkpointManifest[varName].filename; + xhr.open('GET', _this.urlPath + fname); + xhr.onload = function () { + var values = new Float32Array(xhr.response); + var ndarray = ndarray_1.NDArray.make(_this.checkpointManifest[varName].shape, { values: values }); + resolve(ndarray); + }; + xhr.onerror = function (error) { + throw new Error('Could not fetch variable ' + varName + ': ' + error); + }; + xhr.send(); + }; + if (this.checkpointManifest == null) { + return new Promise(function (resolve, reject) { + _this.loadManifest().then(function () { + new Promise(variableRequestPromiseMethod).then(resolve); + }); + }); + } + return new Promise(variableRequestPromiseMethod); + }; + return CheckpointLoader; +}()); +exports.CheckpointLoader = CheckpointLoader; + +},{"./math/ndarray":25}],9:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var STATS_SAMPLE_PERCENTAGE = 0.1; +var InMemoryDataset = (function () { + function InMemoryDataset(dataShapes) { + this.dataShapes = dataShapes; + this.normalizationInfo = {}; + } + InMemoryDataset.prototype.getDataShape = function (dataIndex) { + return this.dataShapes[dataIndex]; + }; + InMemoryDataset.prototype.getData = function () { + return this.dataset; + }; + InMemoryDataset.prototype.getStats = function () { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + return this.dataset.map(function (d) { return _this.getStatsForData(d); }); + }; + InMemoryDataset.prototype.getStatsForData = function (data) { + var inputMin = Number.POSITIVE_INFINITY; + var inputMax = Number.NEGATIVE_INFINITY; + var exampleIndices = data.map(function (example, i) { return i; }); + util.shuffle(exampleIndices); + exampleIndices = + exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE); + for (var i = 0; i < exampleIndices.length; i++) { + var inputValues = data[exampleIndices[i]].getValues(); + for (var j = 0; j < inputValues.length; j++) { + inputMin = Math.min(inputMin, inputValues[j]); + inputMax = Math.max(inputMax, inputValues[j]); + } + } + return { + inputMin: inputMin, + inputMax: inputMax, + exampleCount: data.length, + shape: data[0].shape, + }; + }; + InMemoryDataset.prototype.normalizeExamplesToRange = function (examples, curLowerBounds, curUpperBounds, newLowerBounds, newUpperBounds) { + var curBoundsIsPerDimension = (curUpperBounds instanceof Float32Array && + curLowerBounds instanceof Float32Array); + var newBoundsIsPerDimension = (newLowerBounds instanceof Float32Array && + newUpperBounds instanceof Float32Array); + var inputSize = util.sizeFromShape(examples[0].shape); + var newExamples = []; + examples.forEach(function (example) { + var inputValues = example.getValues(); + var normalizedValues = new Float32Array(inputSize); + for (var j = 0; j < inputSize; j++) { + var curLowerBound = curBoundsIsPerDimension ? + curLowerBounds[j] : + curLowerBounds; + var curUpperBound = curBoundsIsPerDimension ? + curUpperBounds[j] : + curUpperBounds; + var curRange = curUpperBound - curLowerBound; + var newLowerBound = newBoundsIsPerDimension ? + newLowerBounds[j] : + newLowerBounds; + var newUpperBound = newBoundsIsPerDimension ? + newUpperBounds[j] : + newUpperBounds; + var newRange = newUpperBound - newLowerBound; + if (curRange === 0) { + normalizedValues[j] = newLowerBound; + } + else { + normalizedValues[j] = newLowerBound + + newRange * (inputValues[j] - curLowerBound) / curRange; + } + } + newExamples.push(ndarray_1.NDArray.make(example.shape, { values: normalizedValues })); + }); + return newExamples; + }; + InMemoryDataset.prototype.computeBounds = function (dataIndex) { + var _this = this; + if (this.dataset == null) { + throw new Error('Data is null.'); + } + var size = util.sizeFromShape(this.dataset[dataIndex][0].shape); + this.normalizationInfo[dataIndex] = { + isNormalized: false, + minValues: new Float32Array(size), + maxValues: new Float32Array(size) + }; + for (var i = 0; i < size; i++) { + this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY; + this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY; + } + this.dataset[dataIndex].forEach(function (example) { + var inputValues = example.getValues(); + for (var k = 0; k < size; k++) { + _this.normalizationInfo[dataIndex].minValues[k] = Math.min(_this.normalizationInfo[dataIndex].minValues[k], inputValues[k]); + _this.normalizationInfo[dataIndex].maxValues[k] = Math.max(_this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]); + } + }); + }; + InMemoryDataset.prototype.normalizeWithinBounds = function (dataIndex, lowerBound, upperBound) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + if (dataIndex >= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":25,"./util":89}],10:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":11,"./math/concat3d_util":18,"./math/conv_util":19,"./math/ndarray":25,"./util":89}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":15}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":25,"./session":85}],13:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":10,"./priority_queue":84}],14:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":8,"./dataset":9,"./graph":10,"./graph_runner":12,"./initializers":15,"./input_provider":16,"./math/conv_util":19,"./math/math":22,"./math/math_cpu":23,"./math/math_gpu":24,"./math/ndarray":25,"./math/webgl/gpgpu_context":38,"./math/webgl/gpgpu_util":39,"./math/webgl/render_ndarray_gpu_util":51,"./math/webgl/webgl_util":61,"./optimizer":83,"./session":85,"./sgd_optimizer":87,"./util":89}],15:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":25}],16:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":25,"./util":89}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":25}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":89}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":89}],20:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],21:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":25}],22:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":89,"./concat3d_util":18,"./copy2d_util":20,"./ndarray":25}],23:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":19,"../util":89,"./concat3d_util":18,"./copy2d_util":20,"./math":22,"./ndarray":25}],24:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":89,"./concat3d_util":18,"./conv_util":19,"./math":22,"./ndarray":25,"./webgl/addscaledmat_gpu":26,"./webgl/addsubmuldiv_gpu":27,"./webgl/argmaxequals_gpu":28,"./webgl/argminmax_gpu":29,"./webgl/avg_pool_gpu":30,"./webgl/batchnorm_gpu":31,"./webgl/concat3d_gpu":33,"./webgl/conv_backprop_gpu":34,"./webgl/conv_gpu":35,"./webgl/copy_gpu":36,"./webgl/exp_gpu":37,"./webgl/gpgpu_context":38,"./webgl/gpgpu_util":39,"./webgl/log_gpu":40,"./webgl/logsumexp_gpu":41,"./webgl/max_pool_backprop_gpu":42,"./webgl/max_pool_gpu":43,"./webgl/min_pool_gpu":44,"./webgl/minmax_gpu":45,"./webgl/mulmat_gpu":46,"./webgl/neg_gpu":47,"./webgl/pool_gpu":48,"./webgl/reducesum_gpu":49,"./webgl/relu_gpu":50,"./webgl/reshape_gpu":52,"./webgl/resize_bilinear_gpu":53,"./webgl/shader_compiler":54,"./webgl/sigmoid_gpu":55,"./webgl/step_gpu":56,"./webgl/texture_manager":58,"./webgl/trig_gpu":59,"./webgl/webgl_util":61}],25:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":89,"./webgl/webgl_util":61}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":38}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":22,"./binaryop_gpu":32}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":29}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":61}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":48}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":38}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":19}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":19,"./conv_gpu":35}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":19}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":60}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":39,"./tex_util":57,"./webgl_util":61}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":57,"./webgl_util":61}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":60}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":38}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":19}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":48}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":48}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":61}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":22,"./shader_compiler":54}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":60}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":19,"./webgl_util":61}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":38}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":60}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":61}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":89}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":19}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":89}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":60}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":60}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":60}],60:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":38}],61:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":89}],62:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":10,"./graph_util":13,"./ops/add":63,"./ops/argmax":64,"./ops/argmaxequals":65,"./ops/concat3d":66,"./ops/convolution":67,"./ops/divide":68,"./ops/element_wise_activation":69,"./ops/element_wise_cost":70,"./ops/exp":71,"./ops/linear_combination":72,"./ops/log":73,"./ops/matmul":74,"./ops/max_pool":75,"./ops/multiply":76,"./ops/reduce_sum":78,"./ops/reshape":79,"./ops/softmax":80,"./ops/split":81,"./ops/subtract":82}],63:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":13,"../math/ndarray":25,"../util":89,"./op":77}],64:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":77}],65:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":77}],66:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":18,"./op":77}],67:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":19,"../util":89,"./op":77}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":13,"../util":89,"./op":77}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":17,"./op":77}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":13,"../math/cost_functions":21,"../math/ndarray":25,"../util":89,"./op":77}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":13,"./op":77}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":13,"./op":77}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":13,"./op":77}],74:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":13,"../math/math":22,"./op":77}],75:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":19,"../util":89,"./op":77}],76:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":13,"../util":89,"./op":77}],77:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],78:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":13,"../math/ndarray":25,"../util":89,"./op":77}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":89,"./op":77}],80:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":10,"../math/ndarray":25,"../util":89,"./op":77}],81:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":13,"../util":89,"./op":77}],82:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":13,"../math/ndarray":25,"../util":89,"./op":77}],83:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],84:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],85:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":25,"./operation_emitter":62,"./session_util":86,"./tensor_array_map":88,"./util":89}],86:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":10,"./graph_util":13,"./math/ndarray":25,"./util":89}],87:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":25,"./optimizer":83,"./session_util":86,"./tensor_array_map":88}],88:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],89:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[5]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","demos/demo-footer.ts","demos/demo-header.ts","demos/learnjs.ts","demos/nn-art/cppn.ts","demos/nn-art/nn-art.ts","demos/nn-art/nn_art_util.ts","demos/polymer-spec.ts","src/checkpoint_loader.ts","src/dataset.ts","src/graph.ts","src/graph_layers.ts","src/graph_runner.ts","src/graph_util.ts","src/index.ts","src/initializers.ts","src/input_provider.ts","src/math/activation_functions.ts","src/math/concat3d_util.ts","src/math/conv_util.ts","src/math/copy2d_util.ts","src/math/cost_functions.ts","src/math/math.ts","src/math/math_cpu.ts","src/math/math_gpu.ts","src/math/ndarray.ts","src/math/webgl/addscaledmat_gpu.ts","src/math/webgl/addsubmuldiv_gpu.ts","src/math/webgl/argmaxequals_gpu.ts","src/math/webgl/argminmax_gpu.ts","src/math/webgl/avg_pool_gpu.ts","src/math/webgl/batchnorm_gpu.ts","src/math/webgl/binaryop_gpu.ts","src/math/webgl/concat3d_gpu.ts","src/math/webgl/conv_backprop_gpu.ts","src/math/webgl/conv_gpu.ts","src/math/webgl/copy_gpu.ts","src/math/webgl/exp_gpu.ts","src/math/webgl/gpgpu_context.ts","src/math/webgl/gpgpu_util.ts","src/math/webgl/log_gpu.ts","src/math/webgl/logsumexp_gpu.ts","src/math/webgl/max_pool_backprop_gpu.ts","src/math/webgl/max_pool_gpu.ts","src/math/webgl/min_pool_gpu.ts","src/math/webgl/minmax_gpu.ts","src/math/webgl/mulmat_gpu.ts","src/math/webgl/neg_gpu.ts","src/math/webgl/pool_gpu.ts","src/math/webgl/reducesum_gpu.ts","src/math/webgl/relu_gpu.ts","src/math/webgl/render_ndarray_gpu_util.ts","src/math/webgl/reshape_gpu.ts","src/math/webgl/resize_bilinear_gpu.ts","src/math/webgl/shader_compiler.ts","src/math/webgl/sigmoid_gpu.ts","src/math/webgl/step_gpu.ts","src/math/webgl/tex_util.ts","src/math/webgl/texture_manager.ts","src/math/webgl/trig_gpu.ts","src/math/webgl/unaryop_gpu.ts","src/math/webgl/webgl_util.ts","src/operation_emitter.ts","src/ops/add.ts","src/ops/argmax.ts","src/ops/argmaxequals.ts","src/ops/concat3d.ts","src/ops/convolution.ts","src/ops/divide.ts","src/ops/element_wise_activation.ts","src/ops/element_wise_cost.ts","src/ops/exp.ts","src/ops/linear_combination.ts","src/ops/log.ts","src/ops/matmul.ts","src/ops/max_pool.ts","src/ops/multiply.ts","src/ops/op.ts","src/ops/reduce_sum.ts","src/ops/reshape.ts","src/ops/softmax.ts","src/ops/split.ts","src/ops/subtract.ts","src/optimizer.ts","src/priority_queue.ts","src/session.ts","src/session_util.ts","src/sgd_optimizer.ts","src/tensor_array_map.ts","src/util.ts"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-footer'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nPolymer({is: 'demo-header'});\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n// This file is just an alias that points to the current learnjs version\n// at this branch, so demos can import the library as '../learnjs'.\nexport * from '../src/index';\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Array1D, Array2D, gpgpu_util, GPGPUContext, NDArrayMathGPU, Scalar, webgl_util} from '../learnjs';\n\nimport * as nn_art_util from './nn_art_util';\n\nconst MAX_LAYERS = 10;\n\nexport type ColorMode = 'rgb'|'rgba'|'hsv'|'hsva'|'yuv'|'yuva'|'bw';\nconst colorModeOutputDimensions: {[colorMode in ColorMode]: number} = {\n  'rgb': 3,\n  'rgba': 4,\n  'hsv': 3,\n  'hsva': 4,\n  'yuv': 3,\n  'yuva': 4,\n  'bw': 1\n};\n\nexport type ActivationFunction = 'tanh'|'sin'|'relu'|'step';\nconst activationFunctionMap: {\n  [activationFunction in ActivationFunction]:\n      (math: NDArrayMathGPU, ndarray: Array2D) => Array2D\n} = {\n  'tanh': (math: NDArrayMathGPU, ndarray: Array2D) => math.tanh(ndarray),\n  'sin': (math: NDArrayMathGPU, ndarray: Array2D) => math.sin(ndarray),\n  'relu': (math: NDArrayMathGPU, ndarray: Array2D) => math.relu(ndarray),\n  'step': (math: NDArrayMathGPU, ndarray: Array2D) => math.step(ndarray)\n};\n\nconst NUM_IMAGE_SPACE_VARIABLES = 3;  // x, y, r\nconst NUM_LATENT_VARIABLES = 2;\n\nexport class CPPN {\n  private math: NDArrayMathGPU;\n  private gl: WebGLRenderingContext;\n  private gpgpu: GPGPUContext;\n  private renderShader: WebGLProgram;\n  private addLatentVariablesShader: WebGLProgram;\n\n  private inputAtlas: Array2D;\n  private weights: Array2D[] = [];\n\n  private z1Counter = 0;\n  private z2Counter = 0;\n  private z1Scale: number;\n  private z2Scale: number;\n  private numLayers: number;\n\n  private colorModeNames: ColorMode[] =\n      ['rgb', 'rgba', 'hsv', 'hsva', 'yuv', 'yuva', 'bw'];\n  private activationFunctionNames: ActivationFunction[] =\n      ['tanh', 'sin', 'relu', 'step'];\n\n  private selectedColorModeName: ColorMode;\n  private selectedActivationFunctionName: ActivationFunction;\n\n  private isInferring = false;\n\n  constructor(private inferenceCanvas: HTMLCanvasElement) {\n    this.gl = gpgpu_util.createWebGLContext(this.inferenceCanvas);\n    this.gpgpu = new GPGPUContext(this.gl);\n    this.math = new NDArrayMathGPU(this.gpgpu);\n\n    const maxTextureSize = webgl_util.queryMaxTextureSize(this.gl);\n    const canvasSize = Math.floor(Math.sqrt(maxTextureSize));\n    this.inferenceCanvas.width = canvasSize;\n    this.inferenceCanvas.height = canvasSize;\n\n    this.renderShader = nn_art_util.getRenderShader(this.gpgpu, canvasSize);\n    this.addLatentVariablesShader = nn_art_util.getAddLatentVariablesShader(\n        this.gpgpu, NUM_IMAGE_SPACE_VARIABLES);\n    this.inputAtlas = nn_art_util.createInputAtlas(\n        canvasSize, NUM_IMAGE_SPACE_VARIABLES, NUM_LATENT_VARIABLES);\n  }\n\n  generateWeights(neuronsPerLayer: number, weightsStdev: number) {\n    for (let i = 0; i < this.weights.length; i++) {\n      this.weights[i].dispose();\n    }\n    this.weights = [];\n\n    this.weights.push(Array2D.randTruncatedNormal<Array2D>(\n        [neuronsPerLayer, NUM_IMAGE_SPACE_VARIABLES + NUM_LATENT_VARIABLES], 0,\n        weightsStdev));\n    for (let i = 0; i < MAX_LAYERS; i++) {\n      this.weights.push(Array2D.randTruncatedNormal<Array2D>(\n          [neuronsPerLayer, neuronsPerLayer], 0, weightsStdev));\n    }\n    this.weights.push(Array2D.randTruncatedNormal<Array2D>(\n        [4 /** max output channels */, neuronsPerLayer], 0, weightsStdev));\n  }\n\n  setColorMode(colorMode: ColorMode) {\n    this.selectedColorModeName = colorMode;\n  }\n\n  setActivationFunction(activationFunction: ActivationFunction) {\n    this.selectedActivationFunctionName = activationFunction;\n  }\n\n  setNumLayers(numLayers: number) {\n    this.numLayers = numLayers;\n  }\n\n  setZ1Scale(z1Scale: number) {\n    this.z1Scale = z1Scale;\n  }\n\n  setZ2Scale(z2Scale: number) {\n    this.z2Scale = z2Scale;\n  }\n\n  start() {\n    this.isInferring = true;\n    this.runInferenceLoop();\n  }\n\n  private runInferenceLoop() {\n    if (!this.isInferring) {\n      return;\n    }\n\n    const colorModeIndex =\n        this.colorModeNames.indexOf(this.selectedColorModeName);\n    const outputDimensions =\n        colorModeOutputDimensions[this.selectedColorModeName];\n\n    this.z1Counter += 1 / this.z1Scale;\n    this.z2Counter += 1 / this.z2Scale;\n    const z1 = Math.sin(this.z1Counter);\n    const z2 = Math.cos(this.z2Counter);\n\n    const intermediateResults = [];\n\n    // Add the latent variables.\n    const addLatentVariablesResultTex =\n        this.math.getTextureManager().acquireTexture(this.inputAtlas.shape);\n    nn_art_util.addLatentVariables(\n        this.gpgpu, this.addLatentVariablesShader, this.inputAtlas.getTexture(),\n        addLatentVariablesResultTex, this.inputAtlas.shape, z1, z2);\n    const inputAtlasWithLatentVariables =\n        Array2D.make<Array2D>(this.inputAtlas.shape, {\n          texture: addLatentVariablesResultTex,\n          textureShapeRC: this.inputAtlas.shape\n        });\n    intermediateResults.push(inputAtlasWithLatentVariables);\n\n    let lastOutput = inputAtlasWithLatentVariables;\n\n    this.math.scope(() => {\n      for (let i = 0; i < this.numLayers; i++) {\n        const matmulResult = this.math.matMul(this.weights[i], lastOutput);\n\n        lastOutput = (i === this.numLayers - 1) ?\n            this.math.sigmoid(matmulResult) :\n            activationFunctionMap[this.selectedActivationFunctionName](\n                this.math, matmulResult);\n      }\n      nn_art_util.render(\n          this.gpgpu, this.renderShader, lastOutput.getTexture(),\n          outputDimensions, colorModeIndex);\n    });\n\n    inputAtlasWithLatentVariables.dispose();\n\n    requestAnimationFrame(() => this.runInferenceLoop());\n  }\n\n  stopInferenceLoop() {\n    this.isInferring = false;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\nimport '../demo-header';\nimport '../demo-footer';\n\nimport {Array1D, Array2D, gpgpu_util, GPGPUContext, NDArrayMathGPU, Scalar, webgl_util} from '../learnjs';\n// tslint:disable-next-line:no-unused-variable\nimport {PolymerElement, PolymerHTMLElement} from '../polymer-spec';\n\nimport {ActivationFunction, ColorMode, CPPN} from './cppn';\nimport * as nn_art_util from './nn_art_util';\n\nconst CANVAS_UPSCALE_FACTOR = 3;\n\nconst NUM_IMAGE_SPACE_VARIABLES = 3;  // x, y, r\nconst NUM_LATENT_VARIABLES = 2;\n\nconst MAX_NUM_LAYERS = 15;\nconst MAT_WIDTH = 30;\n// Standard deviations for gaussian weight initialization.\nconst WEIGHTS_STDEV = .6;\n\n// tslint:disable-next-line:variable-name\nexport const NNArtPolymer = PolymerElement({is: 'nn-art', properties: {}});\n\nexport class NNArt extends NNArtPolymer {\n  private cppn: CPPN;\n\n  private inferenceCanvas: HTMLCanvasElement;\n\n  private z1Scale: number;\n  private z2Scale: number;\n  private numLayers: number;\n\n  ready() {\n    this.inferenceCanvas =\n        this.querySelector('#inference') as HTMLCanvasElement;\n\n    this.cppn = new CPPN(this.inferenceCanvas);\n\n    this.inferenceCanvas.style.width =\n        this.inferenceCanvas.width * CANVAS_UPSCALE_FACTOR + 'px';\n    this.inferenceCanvas.style.height =\n        this.inferenceCanvas.height * CANVAS_UPSCALE_FACTOR + 'px';\n\n    const currentColorElement =\n        this.querySelector('#colormode') as HTMLInputElement;\n    this.querySelector('#color-selector')!.addEventListener(\n        // tslint:disable-next-line:no-any\n        'click', (event: any) => {\n          const colorMode =\n              (event.target as HTMLElement).getAttribute('data-val') as\n              ColorMode;\n          currentColorElement.value = colorMode;\n          this.cppn.setColorMode(colorMode);\n        });\n    this.cppn.setColorMode('rgb');\n\n    const currentActivationFnElement =\n        this.querySelector('#activation-fn') as HTMLInputElement;\n    this.querySelector('#activation-selector')!.addEventListener(\n        // tslint:disable-next-line:no-any\n        'click', (event: any) => {\n          const activationFn =\n              (event.target as HTMLElement).getAttribute('data-val') as\n              ActivationFunction;\n          currentActivationFnElement.value = activationFn;\n          this.cppn.setActivationFunction(activationFn);\n        });\n    this.cppn.setActivationFunction('tanh');\n\n    const layersSlider =\n        this.querySelector('#layers-slider') as HTMLInputElement;\n    const layersCountElement =\n        this.querySelector('#layers-count') as HTMLDivElement;\n    layersSlider!.addEventListener('input', (event) => {\n      // tslint:disable-next-line:no-any\n      this.numLayers = (event as any).target.value;\n      layersCountElement.innerText = '' + this.numLayers;\n      this.cppn.setNumLayers(this.numLayers);\n    });\n    this.numLayers = +layersSlider.value;\n    layersCountElement.innerText = '' + this.numLayers;\n    this.cppn.setNumLayers(this.numLayers);\n\n    const z1Slider = this.querySelector('#z1-slider') as HTMLInputElement;\n    z1Slider.addEventListener('input', (event) => {\n      // tslint:disable-next-line:no-any\n      this.z1Scale = (event as any).target.value;\n      this.cppn.setZ1Scale(this.z1Scale);\n    });\n    this.z1Scale = +z1Slider.value;\n    this.cppn.setZ1Scale(this.z1Scale);\n\n    const z2Slider = this.querySelector('#z2-slider') as HTMLInputElement;\n    z2Slider.addEventListener('input', (event) => {\n      // tslint:disable-next-line:no-any\n      this.z2Scale = (event as any).target.value;\n      this.cppn.setZ2Scale(this.z1Scale);\n    });\n    this.z2Scale = +z2Slider.value;\n    this.cppn.setZ2Scale(this.z2Scale);\n\n    const randomizeButton = this.querySelector('#random') as HTMLButtonElement;\n    randomizeButton.addEventListener('click', () => {\n      this.cppn.generateWeights(MAT_WIDTH, WEIGHTS_STDEV);\n    });\n\n    this.cppn.generateWeights(MAT_WIDTH, WEIGHTS_STDEV);\n    this.cppn.start();\n  }\n}\n\ndocument.registerElement(NNArt.prototype.is, NNArt);\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Array2D, GPGPUContext, webgl_util} from '../learnjs';\n\nexport function createInputAtlas(\n    imageSize: number, inputNumDimensions: number, numLatentVariables: number) {\n  const coords = new Float32Array(\n      imageSize * imageSize * (inputNumDimensions + numLatentVariables));\n  let dst = 0;\n  for (let d = 0; d < inputNumDimensions + numLatentVariables; d++) {\n    for (let i = 0; i < imageSize * imageSize; i++) {\n      const x = i % imageSize;\n      const y = Math.floor(i / imageSize);\n      const coord = imagePixelToNormalizedCoord(\n          x, y, imageSize, imageSize, numLatentVariables);\n      coords[dst++] = coord[d];\n    }\n  }\n\n  return Array2D.new(\n      [inputNumDimensions + numLatentVariables, imageSize * imageSize], coords);\n}\n\nexport function getAddLatentVariablesShader(\n    gpgpu: GPGPUContext, inputNumDimensions: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    uniform vec2 z;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 outputCR = floor(gl_FragCoord.xy);\n      if (outputCR[1] == ${inputNumDimensions}.0) {\n        gl_FragColor = vec4(z[0], 0, 0, 0);\n      } else if (outputCR[1] > ${inputNumDimensions}.0) {\n        gl_FragColor = vec4(z[1], 0, 0, 0);\n      } else {\n        gl_FragColor = texture2D(source, resultUV);\n      }\n    }`;\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function addLatentVariables(\n    gpgpu: GPGPUContext, addZShader: WebGLProgram, sourceTex: WebGLTexture,\n    resultTex: WebGLTexture, shapeRowCol: [number, number], z1: number,\n    z2: number) {\n  gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]);\n  gpgpu.setProgram(addZShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  const zLoc = gpgpu.getUniformLocation('z');\n  gpgpu.gl.uniform2f(zLoc, z1, z2);\n  gpgpu.executeProgram();\n}\n\nexport function getRenderShader(\n    gpgpu: GPGPUContext, imageSize: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    uniform int colorMode;\n    uniform float outputNumDimensions;\n\n    const float destinationSize = ${imageSize}.0;\n\n    const mat3 yuv2rgb = mat3(\n          1,       1,     1,\n          0, -.34413, 1.772,\n      1.402, -.71414,     0);\n\n    vec3 hsv2rgb(vec3 c) {\n      vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n      vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n      return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n    }\n\n    void main() {\n      vec2 outputCR = floor(gl_FragCoord.xy);\n      float inputC = outputCR.y * destinationSize + outputCR.x;\n      float u = (inputC + 0.5) / ${imageSize * imageSize}.0;\n\n      vec4 inputR = vec4(0.0, 1.0, 2.0, 3.0);\n      vec4 v = (inputR + 0.5) / outputNumDimensions;\n\n      vec4 values = vec4(\n        texture2D(source, vec2(u, v[0])).r,\n        texture2D(source, vec2(u, v[1])).r,\n        texture2D(source, vec2(u, v[2])).r,\n        texture2D(source, vec2(u, v[3])).r);\n\n      if (colorMode == 0) {\n        // RGB\n        gl_FragColor = vec4(values.rgb, 1.0);\n      } else if (colorMode == 1) {\n        // RGBA\n        gl_FragColor = values;\n      } else if (colorMode == 2) {\n        // HSV\n        vec3 rgb = hsv2rgb(values.rgb);\n        gl_FragColor = vec4(rgb, 1.0);\n      } else if (colorMode == 3) {\n        // HSVA\n        vec3 rgb = hsv2rgb(values.rgb);\n        gl_FragColor = vec4(rgb, values[3]);\n      } else if (colorMode == 4 || colorMode == 5) {\n        // YUV\n        values[0] = clamp(values[0], 0.2, 0.8);\n        values[1] = values[1] - 0.5;\n        values[2] = values[2] - 0.5;\n        vec3 rgb = yuv2rgb * values.rgb;\n        if (colorMode == 4) {\n          // YUV\n          gl_FragColor = vec4(rgb, 1.0);\n        } else if (colorMode == 5) {\n          // YUVA\n          gl_FragColor = vec4(rgb, values.a);\n        }\n      } else if (colorMode == 6) {\n        gl_FragColor = vec4(values[0], values[0], values[0], 1.0);\n      }\n    }`;\n\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function render(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture,\n    outputNumDimensions: number, colorMode: number) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  gpgpu.setProgram(renderShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  const colorModeLoc = gpgpu.getUniformLocation('colorMode');\n  gpgpu.gl.uniform1i(colorModeLoc, colorMode);\n  const outputNumDimensionsLoc =\n      gpgpu.getUniformLocation('outputNumDimensions');\n  gpgpu.gl.uniform1f(outputNumDimensionsLoc, outputNumDimensions);\n  gpgpu.executeProgram();\n}\n\n// Normalizes x, y to -.5 <=> +.5, adds a radius term, and pads zeros with the\n// number of z parameters that will get added by the add z shader.\nexport function imagePixelToNormalizedCoord(\n    x: number, y: number, imageWidth: number, imageHeight: number,\n    zSize: number): number[] {\n  const halfWidth = imageWidth * 0.5;\n  const halfHeight = imageHeight * 0.5;\n  const normX = (x - halfWidth) / imageWidth;\n  const normY = (y - halfHeight) / imageHeight;\n\n  const r = Math.sqrt(normX * normX + normY * normY);\n\n  const result = [normX, normY, r];\n\n  // Pad with zeros the number of latent terms, these get added on the GPU as\n  // uniforms.\n  for (let i = 0; i < zSize; i++) {\n    result.push(0);\n  }\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * @fileoverview\n *\n * Defines an interface for creating Polymer elements in Typescript with the\n * correct typings. A Polymer element should be defined like this:\n *\n * ```\n * let MyElementPolymer = PolymerElement({\n *   is: 'my-polymer-element',\n *   properties: {\n *     foo: string,\n *     bar: Array\n *   }\n * });\n *\n * class MyElement extends MyElementPolymer {\n *   foo: string;\n *   bar: number[];\n *\n *   ready() {\n *     console.log('MyElement initialized!');\n *   }\n * }\n *\n * document.registerElement(MyElement.prototype.is, MyElement);\n * ```\n */\n\nexport type Spec = {\n  is: string; properties: {\n    [key: string]: (Function|{\n      // tslint:disable-next-line:no-any\n      type: Function, value?: any;\n      reflectToAttribute?: boolean;\n      readonly?: boolean;\n      notify?: boolean;\n      computed?: string;\n      observer?: string;\n    })\n  };\n  observers?: string[];\n};\n\nexport function PolymerElement(spec: Spec) {\n  // tslint:disable-next-line:no-any\n  return Polymer.Class(spec as any) as {new (): PolymerHTMLElement};\n}\n\nexport interface PolymerHTMLElement extends HTMLElement, polymer.Base {}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * @hidden\n */\nexport interface CheckpointVariable {\n  filename: string;\n  shape: number[];\n}\n\n/**\n * @hidden\n */\nexport type CheckpointManifest = {\n  [varName: string]: CheckpointVariable\n};\n\nconst MANIFEST_FILE = 'manifest.json';\n\nexport class CheckpointLoader {\n  private checkpointManifest: CheckpointManifest;\n  private variables: {[varName: string]: NDArray};\n\n  constructor(private urlPath: string) {\n    if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') {\n      this.urlPath += '/';\n    }\n  }\n\n  private loadManifest(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n      xhr.open('GET', this.urlPath + MANIFEST_FILE);\n\n      xhr.onload = () => {\n        this.checkpointManifest = JSON.parse(xhr.responseText);\n        resolve();\n      };\n      xhr.onerror = (error) => {\n        throw new Error(\n            `${MANIFEST_FILE} not found at ${this.urlPath}. ` + error);\n      };\n      xhr.send();\n    });\n  }\n\n  getCheckpointManifest(): Promise<CheckpointManifest> {\n    if (this.checkpointManifest == null) {\n      return new Promise<CheckpointManifest>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          resolve(this.checkpointManifest);\n        });\n      });\n    }\n    return new Promise<CheckpointManifest>((resolve, reject) => {\n      resolve(this.checkpointManifest);\n    });\n  }\n\n  getAllVariables(): Promise<{[varName: string]: NDArray}> {\n    if (this.variables != null) {\n      return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n        resolve(this.variables);\n      });\n    }\n\n    return new Promise<{[varName: string]: NDArray}>((resolve, reject) => {\n      this.getCheckpointManifest().then(\n          (checkpointDefinition: CheckpointManifest) => {\n            const variableNames = Object.keys(this.checkpointManifest);\n\n            const variablePromises: Array<Promise<NDArray>> = [];\n            for (let i = 0; i < variableNames.length; i++) {\n              variablePromises.push(this.getVariable(variableNames[i]));\n            }\n\n            Promise.all(variablePromises).then(variables => {\n              this.variables = {};\n              for (let i = 0; i < variables.length; i++) {\n                this.variables[variableNames[i]] = variables[i];\n              }\n              resolve(this.variables);\n            });\n          });\n    });\n  }\n\n  getVariable(varName: string): Promise<NDArray> {\n    if (!(varName in this.checkpointManifest)) {\n      throw new Error('Cannot load non-existant variable ' + varName);\n    }\n\n    const variableRequestPromiseMethod =\n        (resolve: (ndarray: NDArray) => void, reject: () => void) => {\n          const xhr = new XMLHttpRequest();\n          xhr.responseType = 'arraybuffer';\n          const fname = this.checkpointManifest[varName].filename;\n          xhr.open('GET', this.urlPath + fname);\n\n          xhr.onload = () => {\n            const values = new Float32Array(xhr.response);\n            const ndarray =\n                NDArray.make(this.checkpointManifest[varName].shape, {values});\n            resolve(ndarray);\n          };\n          xhr.onerror = (error) => {\n            throw new Error(\n                'Could not fetch variable ' + varName + ': ' + error);\n          };\n          xhr.send();\n        };\n\n    if (this.checkpointManifest == null) {\n      return new Promise<NDArray>((resolve, reject) => {\n        this.loadManifest().then(() => {\n          new Promise<NDArray>(variableRequestPromiseMethod).then(resolve);\n        });\n      });\n    }\n    return new Promise<NDArray>(variableRequestPromiseMethod);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\nconst STATS_SAMPLE_PERCENTAGE = 0.1;\n\nexport interface DataStats {\n  exampleCount: number;\n  inputMin: number;\n  inputMax: number;\n  shape: number[];\n}\n\ninterface NormalizationInfo {\n  isNormalized: boolean;\n  // Bounds of the normalization if normalized.\n  lowerBound?: number;\n  upperBound?: number;\n  // Minimum and maximum values for each dimension of the original data. These\n  // are the same size as an input example. These are computed lazily, only if\n  // normalization is requested. If the data is un-normalized, these are kept\n  // around so they don't have to be recomputed.\n  minValues: Float32Array;\n  maxValues: Float32Array;\n}\n\nexport abstract class InMemoryDataset {\n  protected dataset: NDArray[][]|null;\n\n  // Contains information necessary for reconstruction of the original data\n  // after normalization.\n  private normalizationInfo: {[dataIndex: number]: NormalizationInfo};\n\n  constructor(protected dataShapes: number[][]) {\n    this.normalizationInfo = {};\n  }\n\n  getDataShape(dataIndex: number): number[] {\n    return this.dataShapes[dataIndex];\n  }\n\n  abstract fetchData(): Promise<void>;\n\n  getData(): NDArray[][]|null {\n    return this.dataset;\n  }\n\n  getStats(): DataStats[] {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    return this.dataset.map(d => this.getStatsForData(d));\n  }\n\n  // Computes stats across a sampled portion of the data.\n  private getStatsForData(data: NDArray[]): DataStats {\n    let inputMin = Number.POSITIVE_INFINITY;\n    let inputMax = Number.NEGATIVE_INFINITY;\n\n    let exampleIndices = data.map((example, i) => i);\n    util.shuffle(exampleIndices);\n    exampleIndices =\n        exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE);\n\n    for (let i = 0; i < exampleIndices.length; i++) {\n      const inputValues = data[exampleIndices[i]].getValues();\n      for (let j = 0; j < inputValues.length; j++) {\n        inputMin = Math.min(inputMin, inputValues[j]);\n        inputMax = Math.max(inputMax, inputValues[j]);\n      }\n    }\n\n    return {\n      inputMin,\n      inputMax,\n      exampleCount: data.length,\n      shape: data[0].shape,\n    };\n  }\n\n  /**\n   * @param examples NDArrays to be normalized.\n   * @param curLowerBounds An array containing the minimum value for each\n   * dimension or a fixed minimum value.\n   * @param curUpperBounds An array containing the maximum value for each\n   * dimension or a fixed maximum value.\n   * @param newLowerBounds An array containing new minimum values for each\n   * dimension, or a fixed minumum value to normalize the data to.\n   * @param newUpperBounds An array containing new maximum values for each\n   * dimension, or a fixed maximum value to normalize the data to.\n   */\n  private normalizeExamplesToRange(\n      examples: NDArray[], curLowerBounds: Float32Array|number,\n      curUpperBounds: Float32Array|number, newLowerBounds: Float32Array|number,\n      newUpperBounds: Float32Array|number): NDArray[] {\n    const curBoundsIsPerDimension =\n        (curUpperBounds instanceof Float32Array &&\n         curLowerBounds instanceof Float32Array);\n    const newBoundsIsPerDimension =\n        (newLowerBounds instanceof Float32Array &&\n         newUpperBounds instanceof Float32Array);\n\n    const inputSize = util.sizeFromShape(examples[0].shape);\n    const newExamples: NDArray[] = [];\n\n    examples.forEach(example => {\n      const inputValues = example.getValues();\n      const normalizedValues = new Float32Array(inputSize);\n      for (let j = 0; j < inputSize; j++) {\n        const curLowerBound = curBoundsIsPerDimension ?\n            (curLowerBounds as Float32Array)[j] :\n            curLowerBounds as number;\n        const curUpperBound = curBoundsIsPerDimension ?\n            (curUpperBounds as Float32Array)[j] :\n            curUpperBounds as number;\n        const curRange = curUpperBound - curLowerBound;\n\n        const newLowerBound = newBoundsIsPerDimension ?\n            (newLowerBounds as Float32Array)[j] :\n            newLowerBounds as number;\n        const newUpperBound = newBoundsIsPerDimension ?\n            (newUpperBounds as Float32Array)[j] :\n            newUpperBounds as number;\n        const newRange = newUpperBound - newLowerBound;\n\n        if (curRange === 0) {\n          normalizedValues[j] = newLowerBound;\n        } else {\n          normalizedValues[j] = newLowerBound +\n              newRange * (inputValues[j] - curLowerBound) / curRange;\n        }\n      }\n      newExamples.push(NDArray.make(example.shape, {values: normalizedValues}));\n    });\n    return newExamples;\n  }\n\n  private computeBounds(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n\n    const size = util.sizeFromShape(this.dataset[dataIndex][0].shape);\n\n    // Compute min and max values for every dimension.\n    this.normalizationInfo[dataIndex] = {\n      isNormalized: false,\n      minValues: new Float32Array(size),\n      maxValues: new Float32Array(size)\n    };\n\n    for (let i = 0; i < size; i++) {\n      this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY;\n      this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY;\n    }\n\n    this.dataset[dataIndex].forEach(example => {\n      const inputValues = example.getValues();\n      for (let k = 0; k < size; k++) {\n        this.normalizationInfo[dataIndex].minValues[k] = Math.min(\n            this.normalizationInfo[dataIndex].minValues[k], inputValues[k]);\n        this.normalizationInfo[dataIndex].maxValues[k] = Math.max(\n            this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]);\n      }\n    });\n  }\n\n  normalizeWithinBounds(\n      dataIndex: number, lowerBound: number, upperBound: number) {\n    if (this.dataset == null) {\n      throw new Error('Data is null.');\n    }\n    if (dataIndex >= this.dataset.length) {\n      throw new Error('dataIndex out of bounds.');\n    }\n\n    if (this.normalizationInfo[dataIndex] == null) {\n      this.computeBounds(dataIndex);\n    }\n\n    // curLower/UpperBounds of the current data set can either be fixed numbers\n    // if the data has already been normalized, or curLower/Upper for each\n    // dimension if it hasn't been normalized yet.\n    let curLowerBounds: Float32Array|number;\n    let curUpperBounds: Float32Array|number;\n\n    if (this.normalizationInfo[dataIndex].isNormalized) {\n      curLowerBounds = this.normalizationInfo[dataIndex].lowerBound!;\n      curUpperBounds = this.normalizationInfo[dataIndex].upperBound!;\n    } else {\n      curLowerBounds = this.normalizationInfo[dataIndex].minValues;\n      curUpperBounds = this.normalizationInfo[dataIndex].maxValues;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound,\n        upperBound);\n    this.normalizationInfo[dataIndex].isNormalized = true;\n    this.normalizationInfo[dataIndex].lowerBound = lowerBound;\n    this.normalizationInfo[dataIndex].upperBound = upperBound;\n  }\n\n  private isNormalized(dataIndex: number): boolean {\n    return this.normalizationInfo != null &&\n        this.normalizationInfo[dataIndex].isNormalized;\n  }\n\n  removeNormalization(dataIndex: number) {\n    if (this.dataset == null) {\n      throw new Error('Training or test data is null.');\n    }\n\n    if (!this.isNormalized(dataIndex)) {\n      return;\n    }\n\n    this.dataset[dataIndex] = this.normalizeExamplesToRange(\n        this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n    this.normalizationInfo[dataIndex].isNormalized = false;\n  }\n\n  unnormalizeExamples(examples: NDArray[], dataIndex: number): NDArray[] {\n    if (!this.isNormalized(dataIndex)) {\n      return examples;\n    }\n\n    return this.normalizeExamplesToRange(\n        examples, this.normalizationInfo[dataIndex].lowerBound!,\n        this.normalizationInfo[dataIndex].upperBound!,\n        this.normalizationInfo[dataIndex].minValues,\n        this.normalizationInfo[dataIndex].maxValues);\n  }\n\n  dispose() {\n    if (this.dataset == null) {\n      return;\n    }\n\n    for (let i = 0; i < this.dataset.length; i++) {\n      for (let j = 0; j < this.dataset[i].length; j++) {\n        this.dataset[i][j].dispose();\n      }\n    }\n    this.dataset = [];\n  }\n}\n\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GraphLayers} from './graph_layers';\nimport * as concat3d_util from './math/concat3d_util';\nimport * as conv_util from './math/conv_util';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * Graph is the primary container structure for learn.js operations. Graph\n * holds the topology of operation nodes and the connectivity between them.\n */\nexport class Graph {\n  layers: GraphLayers;\n\n  constructor() {\n    this.layers = new GraphLayers(this);\n  }\n\n  /**\n   * Creates a named variable. Variables are tensors that maintain state across\n   * session calls and whose values are adjusted during backpropagation\n   * training.\n   * @param name The name of this variable.\n   * @param data The NDArray to associate with this variable tensor.\n   * @return The tensor representing the variable.\n   */\n  variable(name: string, data: NDArray): Tensor {\n    return this.addNodeAndReturnOutput(new VariableNode(this, name, data));\n  }\n\n  /**\n   * Inserts a placeholder for a tensor that will be always fed. Placeholders\n   * are input tensors whose values are provided by the client via feed\n   * dictionaries. Placeholders are not updated as part of training; they are\n   * only used as immutable input.\n   * @param name The name of this placeholder.\n   * @param shape The shape of the placeholder tensor.\n   * @return The tensor representing the placeholder.\n   */\n  placeholder(name: string, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape));\n  }\n\n  /**\n   * Constant value that persists across session calls.\n   * @param value The value to return.\n   * @return A node outputing the constant value.\n   */\n  constant(value: ArrayData): Tensor {\n    let finalValue: NDArray;\n    if (typeof value === 'number') {\n      finalValue = Scalar.new(value);\n    } else if (value instanceof NDArray) {\n      finalValue = value;\n    } else if (value instanceof Array) {\n      const vals = new Float32Array(util.flatten(value));\n      finalValue = NDArray.make(util.inferShape(value), {values: vals});\n    } else {\n      throw new Error('unimplemented constant type.');\n    }\n    return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue));\n  }\n\n  /**\n   * Reshape the input tensor.\n   * @param x The input tensor to be reshaped.\n   * @param shape The shape of the output tensor.\n   * @return The tensor representing the reshape operation.\n   */\n  reshape(x: Tensor, shape: number[]): Tensor {\n    return this.addNodeAndReturnOutput(\n        new ReshapeNode(this, 'Reshape', x, shape));\n  }\n\n  /**\n   * Computes a fused linear combination of two tensors.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor. Same shape as t1.\n   * @param c1 Coefficient of t1. Must be size 1.\n   * @param c2 Coefficient of t2. Must be size 1.\n   * @return The tensor representing c1*t1+c2*t2.\n   */\n  fusedLinearCombination(x1: Tensor, x2: Tensor, c1: Tensor, c2: Tensor):\n      Tensor {\n    return this.addNodeAndReturnOutput(\n        new FusedLinearCombinationNode(this, x1, x2, c1, c2));\n  }\n\n\n  /**\n   * Adds two tensors (elementwise). Broadcasts if one of the tensors is scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1+t2.\n   */\n  add(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new AddNode(this, x1, x2));\n  }\n\n  /**\n   * Subtracts two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1-t2.\n   */\n  subtract(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2));\n  }\n\n  /**\n   * Multiply two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1*t2.\n   */\n  multiply(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2));\n  }\n\n  /**\n   * Divide two tensors (elementwise). Broadcasts if one of the tensors is\n   * scalar.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing t1 / t2.\n   */\n  divide(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2));\n  }\n\n  /**\n   * Computes the sum of elements in the tensor.\n   * @param x The input tensor.\n   */\n  reduceSum(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReduceSumNode(this, x));\n  }\n\n  /**\n   * Concats two 3D tensors along a given axis.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing concat of two tensors along axis.\n   */\n  concat3d(x1: Tensor, x2: Tensor, axis: number): Tensor {\n    return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis));\n  }\n\n  /**\n   * Computes the dot product between two matrices.\n   * @param x1 The first input tensor.\n   * @param x2 The second input tensor.\n   * @return The tensor representing the dot product of x1 and x2.\n   */\n  matmul(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2));\n  }\n\n  /**\n   * Computes a 2D convolution.\n   * @param x The input tensor to the convolution operation.\n   * @param w The weight tensor used by the convolution operation.\n   * @param b The bias tensor used by the convolution operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param outputDepth The output depth of the convolution operation.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the convolution operation.\n   */\n  conv2d(\n      x: Tensor, w: Tensor, b: Tensor, fieldSize: number, outputDepth: number,\n      stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(new Convolution2DNode(\n        this, x, w, b, fieldSize, outputDepth, stride, zeroPad));\n  }\n\n  /**\n   * Computes a 2D max pool of x.\n   * @param x The input tensor to the max pool operation.\n   * @param fieldSize The size of the convolutional kernel.\n   * @param stride The stride of the convolution operation.\n   * @param zeroPad The amount of zero padding on all sides of the input tensor.\n   * @return The tensor representing the max pool operation.\n   */\n  maxPool(x: Tensor, fieldSize: number, stride = 1, zeroPad?: number): Tensor {\n    return this.addNodeAndReturnOutput(\n        new MaxPoolNode(this, x, fieldSize, stride, zeroPad));\n  }\n\n  /**\n   * Computes exponential of x element-wise.\n   * @param x The input tensor to the exp.\n   * @return The tensor representing the e ^ x operation.\n   */\n  exp(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ExpNode(this, x));\n  }\n\n  /**\n   * Computes log of x element-wise.\n   * @param x The input tensor to the log.\n   * @return The tensor representing the ln(x) operation.\n   */\n  log(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new LogNode(this, x));\n  }\n\n  /**\n   * Computes ReLU of x element-wise.\n   * @param x The input tensor to the ReLU.\n   * @return The tensor representing the ReLU operation.\n   */\n  relu(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ReLUNode(this, x));\n  }\n\n  /**\n   * Computes TanH of x element-wise.\n   * @param x The input tensor to the TanH.\n   * @return The tensor representing the TanH operation.\n   */\n  tanh(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new TanHNode(this, x));\n  }\n\n  /**\n   * Computes Sigmoid of x element-wise.\n   * @param x The input tensor to the sigmoid.\n   * @return The tensor representing the sigmoid operation.\n   */\n  sigmoid(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SigmoidNode(this, x));\n  }\n\n  /**\n   * Computes square of x element-wise.\n   * @param x The input tensor to the square.\n   */\n  square(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SquareNode(this, x));\n  }\n\n  /**\n   * Computes softmax probabilities from logits.\n   *\n   * @param x The input logits.\n   * @return The softmax probabilities.\n   */\n  softmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new SoftmaxNode(this, x));\n  }\n\n  /**\n   * Creates a softmax cross-entropy cost operation in the graph.\n   * @param x The input tensor to classify.\n   * @return The tensor representing the softmax cross-entropy cost operation.\n   */\n  softmaxCrossEntropyCost(x: Tensor, target: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(\n        new SoftmaxCrossEntropyCostNode(this, x, target));\n  }\n\n  /**\n   * Creates a mean-squared cost operation in the graph.\n   * @param label The label tensor.\n   * @param prediction The prediction tensor.\n   * @return The tensor representing the mean-squared cost operation.\n   */\n  meanSquaredCost(label: Tensor, prediction: Tensor) {\n    return this.addNodeAndReturnOutput(\n        new MeanSquaredCostNode(this, label, prediction));\n  }\n\n  /**\n   * Returns the flattened index of the maximum entry in the tensor.\n   * @param x The tensor with the value.\n   * @return A Scalar tensor with the index of the maximum entry.\n   */\n  argmax(x: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxNode(this, x));\n  }\n\n  /**\n   * Creates an argmax equals operation in the graph.\n   * @param x1 First input tensor to check against.\n   * @param x2 Second input tensor to check against.\n   * @return The tensor representing the argmax equals operation.\n   */\n  argmaxEquals(x1: Tensor, x2: Tensor): Tensor {\n    return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2));\n  }\n\n  private addNodeAndReturnOutput(node: Node): Tensor {\n    this.nodes.push(node);\n    node.validate();\n    return node.output;\n  }\n\n  getNodes(): Node[] {\n    return this.nodes;\n  }\n\n  private nodes: Node[] = [];\n}\n\n/**\n * Tensor represents the output of an operation node in the graph.\n * Tensors have no data associated with them, but maintain a shape array\n * to determine operation compatibility. All graph methods that create graph\n * operations return Tensor objects, which can be thought of as 'handles' to\n * operations.\n */\nexport class Tensor {\n  node: Node;\n  id: number;\n  /**\n   * @param shape The shape of this tensor, in dimension sizes.\n   */\n  constructor(public shape: number[]) {\n    this.id = Tensor.nextID++;\n  }\n  private static nextID = 0;\n}\n\n/**\n * Node is the concrete base class for all operations in the graph.\n * Users generally don't need to interact directly with Node instances, but they\n * are provided for informational and introspection purposes.\n *\n * @hidden\n */\nexport abstract class Node {\n  /**\n   * @param graph The graph containing this node\n   * @param name The name of this node\n   * @param inputs A dictionary of named Tensors that comprise this node's\n   * inputs.\n   * @param output This node's output Tensor\n   */\n  constructor(\n      public graph: Graph, public name: string,\n      public inputs: {[name: string]: Tensor}, public output: Tensor) {\n    this.id = Node.nextID++;\n    output.node = this;\n  }\n  abstract validate(): void;\n  id: number;\n  private static nextID = 0;\n}\n\n/**\n * VariableNode represents a variable, a user-provided NDArray that's\n * adjusted during backpropagation training.\n *\n * @hidden\n */\nexport class VariableNode extends Node {\n  constructor(graph: Graph, name: string, public data: NDArray) {\n    super(graph, name, {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding variable op: Data for variable \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * PlaceholderNode represents a placeholder, a user-provided NDArray\n * that's used as immutable input during inference and training.\n *\n * @hidden\n */\nexport class PlaceholderNode extends Node {\n  constructor(graph: Graph, name: string, shape: number[]) {\n    super(graph, name, {}, new Tensor(shape));\n  }\n  validate() {}\n}\n\n/**\n * ConstantNode represents a constant value in the graph.\n *\n * @hidden\n */\nexport class ConstantNode extends Node {\n  constructor(graph: Graph, public data: NDArray) {\n    super(graph, 'Constant', {}, new Tensor(data.shape));\n  }\n  validate() {\n    util.assert(\n        this.data != null,\n        'Error adding constant: data for placeholder \\'' + this.name +\n            '\\' is null or undefined');\n  }\n}\n\n/**\n * ReshapeNode represents a reshape operation in the graph.\n *\n * @hidden\n */\nexport class ReshapeNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, public name: string, private x: Tensor,\n      private shape: number[]) {\n    super(graph, name, {x}, new Tensor(shape));\n  }\n  validate() {\n    const xSize = util.sizeFromShape(this.x.shape);\n    const shapeSize = util.sizeFromShape(this.shape);\n    util.assert(\n        xSize === shapeSize,\n        'Error making reshape operation: input Tensor to reshape \\'' +\n            this.name + '\\' of shape (' + this.x.shape +\n            ') does not match size of requested shape ' + this.shape + '.');\n  }\n}\n\n/**\n * LinearCombinationNode represents a linear combination of two tensors.\n * @hidden\n */\nexport class FusedLinearCombinationNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n  static readonly C1 = 'c1';\n  static readonly C2 = 'c2';\n  constructor(\n      graph: Graph, private t1: Tensor, private t2: Tensor, private c1: Tensor,\n      private c2: Tensor) {\n    super(graph, 'Linear Combination', {t1, t2, c1, c2}, new Tensor(t1.shape));\n  }\n\n  validate() {\n    util.assertShapesMatch(this.t1.shape, this.t2.shape);\n    if (!util.isScalarShape(this.c1.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c1 is not a scalar, got ' +\n          'shape: ' + this.c1.shape);\n    }\n    if (!util.isScalarShape(this.c2.shape)) {\n      throw new Error(\n          'Error adding fusedLinearCombination: c2 is not a scalar, got ' +\n          'shape: ' + this.c2.shape);\n    }\n  }\n}\n\n/**\n * @hidden\n */\nexport class AddNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Add', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding add operation op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SubtractNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Subtract', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding subtract op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class MultiplyNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Multiply', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding multiply op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class DivideNode extends Node {\n  static readonly T1 = 't1';\n  static readonly T2 = 't2';\n\n  constructor(graph: Graph, private t1: Tensor, private t2: Tensor) {\n    super(\n        graph, 'Divide', {t1, t2},\n        new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape));\n  }\n\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.t1.shape) === 1 ||\n            util.sizeFromShape(this.t2.shape) === 1 ||\n            util.arraysEqual(this.t1.shape, this.t2.shape),\n        'Error adding divide op: one of inputs must be scalar or the ' +\n            'shapes ' + this.t1.shape + ' and ' + this.t2.shape +\n            ' must match.');\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReduceSumNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReduceSum', {x}, new Tensor([]));\n  }\n\n  validate() {}\n}\n\n/**\n * Concat3DNode represents a 3D concatenation of two tensors along an axis.\n * @hidden\n */\nexport class Concat3DNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  static readonly AXIS = 'axis';\n  constructor(\n      graph: Graph, private x1: Tensor, private x2: Tensor,\n      public axis: number) {\n    super(\n        graph, 'Concat3D', {x1, x2},\n        new Tensor(concat3d_util.computeConcat3DOutputShape(\n            x1.shape, x2.shape, axis)));\n  }\n  validate() {\n    concat3d_util.assertConcat3DShapesMatch(\n        this.x1.shape, this.x2.shape, this.axis);\n  }\n}\n\nfunction getMatMulOutputShape(x1Shape: number[], x2Shape: number[]): number[] {\n  if (x1Shape.length === 1 && x2Shape.length === 1) {\n    return [1];\n  } else if (x1Shape.length === 1 && x2Shape.length === 2) {\n    return [x2Shape[1]];\n  } else if (x1Shape.length === 2 && x2Shape.length === 1) {\n    return [x1Shape[0]];\n  }\n  return [x1Shape[0], x2Shape[1]];\n}\n\n/**\n * MatMulNode represents a fully connected layer in the graph.\n * @hidden\n */\nexport class MatMulNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(\n        graph, 'MatMul', {x1, x2},\n        new Tensor(getMatMulOutputShape(x1.shape, x2.shape)));\n  }\n\n  validate() {\n    if (this.x1.shape.length === 2 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: inner shapes of matrices with shapes ' +\n              this.x1.shape + ' and ' + this.x2.shape + ' must match.');\n    } else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) {\n      util.assert(\n          this.x1.shape[1] === this.x2.shape[0],\n          'Error adding matmul op: second dimension of matrix with shape ' +\n              this.x1.shape + ' must match size of vector with shape ' +\n              this.x2.shape + '.');\n    } else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) {\n      util.assert(\n          this.x1.shape[0] === this.x2.shape[0],\n          'Error adding matmul op: size of vector with shape ' + this.x1.shape +\n              ' must match first dimension of matrix with ' +\n              'shape ' + this.x2.shape + '.');\n    } else {\n      throw new Error(\n          'Error adding matmul op: inputs must be vectors or matrices.');\n    }\n  }\n}\n\n/**\n * Convolution2DNode represents a 2d convolution operation in the graph.\n * @hidden\n */\nexport class Convolution2DNode extends Node {\n  static readonly X = 'x';\n  static readonly W = 'w';\n  static readonly B = 'b';\n  constructor(\n      graph: Graph, private x: Tensor, private w: Tensor, private b: Tensor,\n      public fieldSize: number, public outputDepth: number, public stride = 1,\n      public zeroPad?: number) {\n    super(\n        graph, 'Convolution 2D', {x, w, b},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, outputDepth, stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding conv2d op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n    util.assert(\n        this.w.shape.length === 4,\n        'Error adding conv2d op: weights must be of rank 4, but got shape: ' +\n            this.w.shape + '.');\n    util.assert(\n        this.b.shape.length === 1,\n        'Error adding conv2d op: biases must be of rank 1, but got shape: ' +\n            this.b.shape + '.');\n\n    util.assert(\n        this.x.shape[2] === this.w.shape[2],\n        'Error adding conv2d op: depth of input (' + this.x.shape[2] +\n            ') must match input depth for weights (' + this.w.shape[2] + ').');\n  }\n}\n\n/**\n * MaxPoolNode represents a 2d max pool operation in the graph.\n * @hidden\n */\nexport class MaxPoolNode extends Node {\n  static readonly X = 'x';\n  constructor(\n      graph: Graph, private x: Tensor, public fieldSize: number,\n      public stride = 1, public zeroPad?: number) {\n    super(\n        graph, 'Max pool', {x},\n        new Tensor(conv_util.computeOutputShape3D(\n            x.shape as [number, number, number], fieldSize, x.shape[2], stride,\n            zeroPad)));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 3,\n        'Error adding maxPool op: input must be of rank 3, but got shape: ' +\n            this.x.shape + '.');\n  }\n}\n\n/**\n * ReLUNode represents a ReLU operation in the graph.\n * @hidden\n */\nexport class ReLUNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'ReLU', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * ExpNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class ExpNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Exp', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * LogNode represents a Exponentiation operation in the graph.\n * @hidden\n */\nexport class LogNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Log', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * TanHNode represents a tanh operation in the graph.\n * @hidden\n */\nexport class TanHNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'TanH', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SigmoidNode represents a sigmoid operation in the graph.\n * @hidden\n */\nexport class SigmoidNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Sigmoid', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * Square node represents an element-wise square operation in the graph.\n * @hidden\n */\nexport class SquareNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'Square', {x}, new Tensor(x.shape));\n  }\n  validate() {}\n}\n\n/**\n * SoftmaxCrossEntropyCostNode represents a softmax cross-entropy cost operation\n * in the graph.\n * @hidden\n */\nexport class SoftmaxCrossEntropyCostNode extends Node {\n  static readonly X = 'x';\n  static readonly TARGET = 'target';\n  constructor(graph: Graph, private x: Tensor, private target: Tensor) {\n    super(graph, 'SoftmaxCrossEntropyCost', {x, target}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x.shape, this.target.shape),\n        'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape +\n            ') must match target shape (' + this.target.shape + ').');\n  }\n}\n\n/**\n * @hidden\n */\nexport class SoftmaxNode extends Node {\n  static readonly X = 'x';\n\n  constructor(graph: Graph, private x: Tensor) {\n    super(graph, 'Softmax', {x}, new Tensor(x.shape));\n  }\n  validate() {\n    util.assert(\n        this.x.shape.length === 1,\n        'The input to a softmax must be a 1-D tensor');\n    util.assert(\n        this.x.shape[0] >= 2,\n        'The input to a softmax must have at least 2 values');\n  }\n}\n\n/**\n * MeanSquaredCostNode represents a mean squared cost operation\n * in the graph.\n *\n * @hidden\n */\nexport class MeanSquaredCostNode extends Node {\n  static readonly LABEL = 'label';\n  static readonly PREDICTION = 'prediction';\n  constructor(graph: Graph, private label: Tensor, private prediction: Tensor) {\n    super(graph, 'Mean Squared Cost', {label, prediction}, new Tensor([]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.label.shape, this.prediction.shape),\n        'Error adding meanSquaredCost op: label shape (' + this.label.shape +\n            ') must match prediction shape (' + this.prediction.shape + ').');\n  }\n}\n\n/**\n * ArgMaxNode represents an argmax operation in the graph.\n * @hidden\n */\nexport class ArgMaxNode extends Node {\n  static readonly X = 'x';\n  constructor(graph: Graph, public x: Tensor) {\n    super(graph, 'ArgMax', {x}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.sizeFromShape(this.x.shape) > 0,\n        'Error adding argmax op: input tensor must have at least one entry.');\n  }\n}\n\n/**\n * ArgMaxEqualsNode represents a argmax equals operation in the graph.\n * @hidden\n */\nexport class ArgMaxEqualsNode extends Node {\n  static readonly X1 = 'x1';\n  static readonly X2 = 'x2';\n  constructor(graph: Graph, private x1: Tensor, private x2: Tensor) {\n    super(graph, 'ArgMaxEquals', {x1, x2}, new Tensor([1]));\n  }\n  validate() {\n    util.assert(\n        util.arraysEqual(this.x1.shape, this.x2.shape),\n        'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape +\n            ') must match x2 shape (' + this.x2.shape + ').');\n  }\n}\n\n/**\n * Split nodes are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n * @hidden\n */\nexport class SplitNode extends Node {\n  static readonly X = 'x';\n\n  outputs: Tensor[] = [];\n\n  constructor(graph: Graph, x: Tensor) {\n    super(graph, 'SplitNode', {x}, new Tensor(x.shape));\n  }\n\n  /**\n   * Registers a new consumer of this split node, i.e. a new node that uses the\n   * node's output tensor.\n   */\n  getNewOutputTensor(): Tensor {\n    const output = new Tensor(this.inputs[SplitNode.X].shape);\n    output.node = this;\n    this.outputs.push(output);\n    return output;\n  }\n  validate() {}\n}\n\n/**\n * @hidden\n */\nexport type ArrayData =\n    NDArray|number|number[]|number[][]|number[][][]|number[][][][];\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Tensor} from './graph';\nimport {Initializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nimport {NDArray} from './math/ndarray';\n\n/**\n * A layers sugar class around the graph that initializes variables\n * automatically for layers.\n */\nexport class GraphLayers {\n  constructor(private g: Graph) {}\n\n  dense(\n      name: string, x: Tensor, units: number,\n      activation: ((x: Tensor) => Tensor)|null = null, useBias = true,\n      kernelInitializer: Initializer = new VarianceScalingInitializer(),\n      biasInitializer: Initializer = new ZerosInitializer()) {\n    const weights = this.g.variable(\n        name + '-weights',\n        kernelInitializer.initialize([x.shape[0], units], x.shape[0], units));\n\n    let out = this.g.matmul(x, weights);\n\n    if (useBias) {\n      const bias = this.g.variable(\n          name + '-bias',\n          biasInitializer.initialize([units], x.shape[0], units));\n      out = this.g.add(out, bias);\n    }\n\n    if (activation != null) {\n      out = activation(out);\n    }\n\n    return out;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as dataset from './dataset';\nimport {Graph, Tensor} from './graph';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArrayMathCPU} from './math/math_cpu';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {CostReduction, FeedEntry, Session} from './session';\n\nconst DEFAULT_EVAL_INTERVAL_MS = 1500;\nconst DEFAULT_COST_INTERVAL_MS = 500;\nconst DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000;\n\nexport interface GraphRunnerEventObserver {\n  batchesTrainedCallback?: (totalBatchesTrained: number) => void;\n  avgCostCallback?: (avgCost: Scalar) => void;\n  metricCallback?: (metric: NDArray) => void;\n  inferenceExamplesCallback?:\n      (feeds: FeedEntry[][], inferenceValues: NDArray[]) => void;\n  inferenceExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  trainExamplesPerSecCallback?: (examplesPerSec: number) => void;\n  totalTimeCallback?: (totalTimeSec: number) => void;\n  doneTrainingCallback?: () => void;\n}\n\nexport enum MetricReduction {\n  SUM,\n  MEAN\n}\n\n/**\n * A class that drives the training of a graph model given a dataset. It allows\n * the user to provide a set of callbacks for measurements like cost, accuracy,\n * and speed of training.\n */\nexport class GraphRunner {\n  private costTensor: Tensor;\n  private trainFeedEntries: FeedEntry[];\n  private batchSize: number;\n  private optimizer: Optimizer;\n  private currentTrainLoopNumBatches: number|undefined;\n  private costIntervalMs: number;\n\n  private metricTensor: Tensor|undefined;\n  private metricFeedEntries: FeedEntry[]|undefined;\n  private metricBatchSize: number|undefined;\n  private metricReduction: MetricReduction;\n  private metricIntervalMs: number;\n\n  private inferenceTensor: Tensor;\n  private inferenceFeedEntries: FeedEntry[]|undefined;\n  private inferenceExampleIntervalMs: number;\n  private inferenceExampleCount: number;\n\n  // Runtime information.\n  private isTraining: boolean;\n  private totalBatchesTrained: number;\n  private batchesTrainedThisRun: number;\n  private lastComputedMetric: NDArray;\n\n  private isInferring: boolean;\n  private currentInferenceLoopNumPasses: number|undefined;\n  private inferencePassesThisRun: number;\n\n  private trainStartTimestamp: number;\n  private lastCostTimestamp = 0;\n  private lastEvalTimestamp = 0;\n\n  private lastStopTimestamp: number|null;\n  private totalIdleTimeMs = 0;\n\n  private zeroScalar: Scalar;\n  private metricBatchSizeScalar: Scalar;\n\n  constructor(\n      private math: NDArrayMath, private session: Session,\n      private eventObserver: GraphRunnerEventObserver) {\n    this.resetStatistics();\n    this.zeroScalar = Scalar.new(0);\n  }\n\n  resetStatistics() {\n    this.totalBatchesTrained = 0;\n    this.totalIdleTimeMs = 0;\n    this.lastStopTimestamp = null;\n  }\n\n  /**\n   * Start the training loop with an optional number of batches to train for.\n   * Optionally takes a metric tensor and feed entries to compute periodically.\n   * This can be used for computing accuracy, or a similar metric.\n   */\n  train(\n      costTensor: Tensor, trainFeedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, numBatches?: number, metricTensor?: Tensor,\n      metricFeedEntries?: FeedEntry[], metricBatchSize?: number,\n      metricReduction = MetricReduction.MEAN,\n      evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS,\n      costIntervalMs = DEFAULT_COST_INTERVAL_MS) {\n    this.costTensor = costTensor;\n    this.trainFeedEntries = trainFeedEntries;\n    this.metricTensor = metricTensor;\n    this.metricFeedEntries = metricFeedEntries;\n    if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) {\n      if (this.metricBatchSizeScalar != null) {\n        this.metricBatchSizeScalar.dispose();\n      }\n      this.metricBatchSizeScalar = Scalar.new(metricBatchSize);\n    }\n    this.metricBatchSize = metricBatchSize;\n    this.metricReduction = metricReduction;\n    this.batchSize = batchSize;\n    this.optimizer = optimizer;\n\n    this.metricIntervalMs = evalIntervalMs;\n    this.costIntervalMs = costIntervalMs;\n    this.currentTrainLoopNumBatches = numBatches;\n\n    this.batchesTrainedThisRun = 0;\n    this.isTraining = true;\n    this.trainStartTimestamp = performance.now();\n    this.trainNetwork();\n  }\n\n  stopTraining() {\n    this.isTraining = false;\n    this.lastStopTimestamp = performance.now();\n  }\n\n  resumeTraining() {\n    this.isTraining = true;\n    if (this.lastStopTimestamp != null) {\n      this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp;\n    }\n    this.trainNetwork();\n  }\n\n  private trainNetwork() {\n    if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) {\n      this.stopTraining();\n    }\n\n    if (!this.isTraining) {\n      if (this.eventObserver.doneTrainingCallback != null) {\n        this.eventObserver.doneTrainingCallback();\n      }\n      return;\n    }\n\n    const start = performance.now();\n    const shouldComputeCost = this.eventObserver.avgCostCallback != null &&\n        (start - this.lastCostTimestamp > this.costIntervalMs);\n    if (shouldComputeCost) {\n      this.lastCostTimestamp = start;\n    }\n\n    const costReduction =\n        shouldComputeCost ? CostReduction.MEAN : CostReduction.NONE;\n\n    this.math.scope((keep) => {\n      const avgCost = this.session.train(\n          this.costTensor, this.trainFeedEntries, this.batchSize,\n          this.optimizer, costReduction);\n\n      if (shouldComputeCost) {\n        const trainTime = performance.now() - start;\n\n        this.eventObserver.avgCostCallback!(avgCost);\n\n        if (this.eventObserver.trainExamplesPerSecCallback != null) {\n          const examplesPerSec = (this.batchSize * 1000 / trainTime);\n          this.eventObserver.trainExamplesPerSecCallback(examplesPerSec);\n        }\n      }\n\n      if (this.eventObserver.metricCallback != null &&\n          this.metricFeedEntries != null &&\n          start - this.lastEvalTimestamp > this.metricIntervalMs) {\n        this.lastEvalTimestamp = start;\n\n        if (this.lastComputedMetric != null) {\n          this.lastComputedMetric.dispose();\n        }\n        this.lastComputedMetric = this.computeMetric();\n        this.eventObserver.metricCallback(this.lastComputedMetric);\n      }\n\n      if (this.eventObserver.totalTimeCallback != null) {\n        this.eventObserver.totalTimeCallback(\n            (start - this.trainStartTimestamp) / 1000);\n      }\n\n      this.batchesTrainedThisRun++;\n      this.totalBatchesTrained++;\n\n      if (this.eventObserver.batchesTrainedCallback != null) {\n        this.eventObserver.batchesTrainedCallback(this.totalBatchesTrained);\n      }\n\n    });\n    setTimeout(() => this.trainNetwork());\n  }\n\n  infer(\n      inferenceTensor: Tensor, inferenceFeedEntries: FeedEntry[],\n      inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS,\n      inferenceExampleCount = 5, numPasses?: number) {\n    if (this.eventObserver.inferenceExamplesCallback == null &&\n        this.eventObserver.inferenceExamplesPerSecCallback == null) {\n      throw new Error(\n          'Cannot start inference loop, no inference example or ' +\n          'examples/sec observer provided.');\n    }\n\n    // Make sure the feed values are providers, and not NDArrays.\n    for (let i = 0; i < inferenceFeedEntries.length; i++) {\n      const feedEntry = inferenceFeedEntries[i];\n\n      if (feedEntry.data instanceof NDArray) {\n        throw new Error(\n            'Cannot start inference on the model runner with feed entries of ' +\n            'type NDArray. Please use InputProviders.');\n      }\n    }\n\n    this.inferenceExampleIntervalMs = inferenceExampleIntervalMs;\n    this.inferenceTensor = inferenceTensor;\n    this.inferenceFeedEntries = inferenceFeedEntries;\n    this.inferenceExampleCount = inferenceExampleCount;\n    this.currentInferenceLoopNumPasses = numPasses;\n    if (!this.isInferring) {\n      this.inferencePassesThisRun = 0;\n      setTimeout(() => this.inferNetwork());\n    }\n    this.isInferring = true;\n  }\n\n  private inferNetwork() {\n    if (!this.isInferring ||\n        this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) {\n      return;\n    }\n\n    this.math.scope((keep, track) => {\n      const feeds: FeedEntry[][] = [];\n      const inferenceValues: NDArray[] = [];\n\n      const start = performance.now();\n      for (let i = 0; i < this.inferenceExampleCount; i++) {\n        // Populate a new FeedEntry[] populated with NDArrays.\n        const ndarrayFeedEntries: FeedEntry[] = [];\n        for (let j = 0; j < this.inferenceFeedEntries!.length; j++) {\n          const feedEntry = this.inferenceFeedEntries![j];\n          ndarrayFeedEntries.push({\n            tensor: feedEntry.tensor,\n            data:\n                track((feedEntry.data as InputProvider).getNextCopy(this.math))\n          });\n        }\n        feeds.push(ndarrayFeedEntries);\n\n        inferenceValues.push(\n            this.session.eval(this.inferenceTensor, ndarrayFeedEntries));\n      }\n\n      if (this.eventObserver.inferenceExamplesPerSecCallback != null) {\n        // Force a GPU download, since inference results are generally needed on\n        // the CPU and it's more fair to include blocking on the GPU to complete\n        // its work for the inference measurement.\n        inferenceValues[inferenceValues.length - 1].getValues();\n\n        const inferenceExamplesPerSecTime = performance.now() - start;\n\n        const examplesPerSec =\n            (this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime);\n        this.eventObserver.inferenceExamplesPerSecCallback!(examplesPerSec);\n      }\n\n      if (this.eventObserver.inferenceExamplesCallback != null) {\n        this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues);\n      }\n      this.inferencePassesThisRun++;\n\n    });\n    setTimeout(() => this.inferNetwork(), this.inferenceExampleIntervalMs);\n  }\n\n  stopInferring() {\n    this.isInferring = false;\n  }\n\n  isInferenceRunning(): boolean {\n    return this.isInferring;\n  }\n\n  computeMetric(): Scalar {\n    if (this.metricFeedEntries == null) {\n      throw new Error('Cannot compute metric, no metric FeedEntries provided.');\n    }\n\n    let metric = this.zeroScalar;\n\n    return this.math.scope((keep) => {\n      for (let i = 0; i < this.metricBatchSize!; i++) {\n        const metricValue =\n            this.session.eval(this.metricTensor!, this.metricFeedEntries!);\n\n        metric = this.math.add(metric, metricValue);\n      }\n\n      if (this.metricReduction === MetricReduction.MEAN) {\n        metric = this.math.divide(metric, this.metricBatchSizeScalar);\n      }\n\n      return metric;\n    });\n  }\n\n  getTotalBatchesTrained(): number {\n    return this.totalBatchesTrained;\n  }\n\n  getLastComputedMetric(): Scalar {\n    return this.lastComputedMetric;\n  }\n\n  setMath(math: NDArrayMath) {\n    this.math = math;\n  }\n\n  setSession(session: Session) {\n    this.session = session;\n  }\n\n  setInferenceTensor(inferenceTensor: Tensor) {\n    this.inferenceTensor = inferenceTensor;\n  }\n\n  setInferenceExampleCount(inferenceExampleCount: number) {\n    this.inferenceExampleCount = inferenceExampleCount;\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Graph, Node, PlaceholderNode, Tensor, VariableNode} from './graph';\nimport * as priority_queue from './priority_queue';\nimport {PriorityQueue} from './priority_queue';\nimport {TensorArrayMap} from './tensor_array_map';\n\n/**\n * Given a target node in a graph, accumulate the set of all nodes that need to\n * be evaluated in order to evaluate the target graph. Traversal stops anywhere\n * a node's values are fed in externally via \"feed dicts\".\n * @param nodes The nodes to be evaluated.\n * @param terminatingNodes The set of nodes that stop traversal.\n * @return The unordered set of nodes that need to be evaluated.\n */\nexport function getUnorderedEvaluationSet(\n    nodes: Node[], terminatingNodes: Node[]): Node[] {\n  const terminatingNodeMap: {[id: number]: Node} = {};\n  const seen: {[id: number]: Node} = {};\n  const set: Node[] = [];\n  const visit: Node[] = nodes.slice();\n  terminatingNodes.forEach(node => terminatingNodeMap[node.id] = node);\n  /* Flood fill: While the 'to visit' stack is not empty, pop a node off of it.\n   * If the node has not yet been visited, add it to the set, mark it as seen,\n   * and enqueue all of its ancestor (input) nodes. */\n  while (visit.length !== 0) {\n    const cur = visit.pop()!;\n    if (seen[cur.id] == null) {\n      if (terminatingNodeMap[cur.id] == null) {\n        Object.keys(cur.inputs)\n            .map(inputName => cur.inputs[inputName])\n            .forEach(input => visit.push(input.node));\n      }\n      set.push(cur);\n      seen[cur.id] = cur;\n    }\n  }\n  return set;\n}\n\n/**\n * Given a set of nodes, compute their order such that all dependent nodes are\n * evaluated after their dependees. This is the 'inference order' for nodes in\n * the operation graph.\n * @param unorderedEvaluationSet The unordered set of nodes that need to be\n * evaluated.\n * @return The input nodes in forward evaluation order.\n */\nexport function getOrderedEvaluationSet(unorderedEvaluationSet: Node[]):\n    Node[] {\n  /* A priority queue is used, where the priority is the remaining number of\n   * unevaluated nodes whose inputs come from the element node. This guarantees\n   * that all downstream nodes will be dequeued before their ancestors. */\n  const set: Node[] = [];\n  const nodeIndices: {[id: number]: number} = {};\n  const pendingDependencies: {[id: number]: number} = {};\n\n  /* The queue priority callback looks at the number of pending dependencies of\n   * a given node. The queue index observer callback maintains the location of\n   * each node in the array, for priority updates. */\n  const nodeQueue = new PriorityQueue<Node>(\n      (a: Node, b: Node) => priority_queue.defaultCompare(\n          pendingDependencies[a.id], pendingDependencies[b.id]),\n      (node: Node, newIndex: number) => nodeIndices[node.id] = newIndex);\n\n  unorderedEvaluationSet.forEach(node => pendingDependencies[node.id] = 0);\n\n  /* For every descendent of a node (output of ancestor is input to descendant),\n   * increment the 'pending dependency count' for the ancestor. This prepares\n   * the 'pending dependency count' as a priority map. */\n  unorderedEvaluationSet.forEach(\n      node => Object.keys(node.inputs)\n                  .map(key => node.inputs[key])\n                  .forEach(input => {\n                    if (unorderedEvaluationSet.indexOf(input.node) !== -1) {\n                      pendingDependencies[input.node.id]++;\n                    }\n                  }));\n\n  unorderedEvaluationSet.forEach(node => nodeQueue.enqueue(node));\n\n  while (!nodeQueue.empty()) {\n    set.unshift(nodeQueue.dequeue());\n    /* As each node is visited, decrement the 'pending dependency count' of\n     * each ancestor, and tell the priority queue that the priority has changed.\n     */\n    Object.keys(set[0].inputs).map(key => set[0].inputs[key]).forEach(input => {\n      if (unorderedEvaluationSet.indexOf(input.node) === -1) {\n        return;\n      }\n      pendingDependencies[input.node.id]--;\n      nodeQueue.update(input.node, nodeIndices[input.node.id]);\n    });\n  }\n\n  return set;\n}\n\n/**\n * @return True iff the node is an input node.\n */\nexport function isInputNode(node: Node): boolean {\n  return Object.keys(node.inputs).length === 0;\n}\n\nexport function shouldBackProp(t: Tensor): boolean {\n  return !(t.node instanceof ConstantNode);\n}\n\nexport function isPassthroughNode(node: Node, map: TensorArrayMap): boolean {\n  const keys = Object.keys(node.inputs);\n  for (let i = 0; i < keys.length; i++) {\n    const input = node.inputs[keys[i]];\n    if (map.get(input, true) === map.get(node.output, true)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from './math/conv_util';\nimport * as gpgpu_util from './math/webgl/gpgpu_util';\nimport * as render_ndarray_gpu_util from './math/webgl/render_ndarray_gpu_util';\nimport * as webgl_util from './math/webgl/webgl_util';\nimport * as util from './util';\n\nexport {CheckpointLoader} from './checkpoint_loader';\nexport {DataStats, InMemoryDataset} from './dataset';\nexport {Graph, Tensor} from './graph';\nexport {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner';\nexport {ConstantInitializer, Initializer, NDArrayInitializer, OnesInitializer, RandomNormalInitializer, RandomTruncatedNormalInitializer, RandomUniformInitializer, VarianceScalingInitializer, ZerosInitializer} from './initializers';\nexport {InCPUMemoryShuffledInputProviderBuilder, InGPUMemoryShuffledInputProviderBuilder, InputProvider} from './input_provider';\nexport {MatrixOrientation, NDArrayMath} from './math/math';\nexport {NDArrayMathCPU} from './math/math_cpu';\nexport {NDArrayMathGPU} from './math/math_gpu';\nexport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './math/ndarray';\nexport {GPGPUContext} from './math/webgl/gpgpu_context';\nexport {Optimizer} from './optimizer';\nexport {CostReduction, FeedEntry, Session} from './session';\nexport {SGDOptimizer} from './sgd_optimizer';\n// Second level exports.\nexport {conv_util, gpgpu_util, render_ndarray_gpu_util, util, webgl_util};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArray} from './math/ndarray';\n\n/**\n * Initializer interface, all initializer implement this interface.\n */\nexport interface Initializer {\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray;\n}\n\nexport class VarianceScalingInitializer implements Initializer {\n  constructor(\n      private scale = 1.0,\n      private mode: 'fan_in'|'fan_out'|'fan_avg' = 'fan_in',\n      private distribution: 'uniform'|'normal' = 'normal') {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    let n = 0;\n    if (this.mode === 'fan_in') {\n      n = inputUnits;\n    } else if (this.mode === 'fan_out') {\n      n = outputUnits;\n    } else if (this.mode === 'fan_avg') {\n      n = (inputUnits + outputUnits) / 2;\n    } else {\n      throw new Error(\n          'Unexpected mode for variance scaling initializer: ' + this.mode);\n    }\n\n    if (this.distribution === 'normal') {\n      return NDArray.randTruncatedNormal(\n          weightsShape, 0.0, Math.sqrt(this.scale / n));\n    } else if (this.distribution === 'uniform') {\n      return NDArray.randUniform(\n          weightsShape, 0.0, Math.sqrt(3 * this.scale / n));\n    } else {\n      throw new Error(\n          'Unexpected distribution for variance scaling initializer: ' +\n          this.distribution);\n    }\n  }\n}\n\nexport class ZerosInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.zeros(weightsShape);\n  }\n}\n\nexport class OnesInitializer implements Initializer {\n  constructor() {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(1);\n    return values;\n  }\n}\n\nexport class ConstantInitializer implements Initializer {\n  constructor(private value = 0) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    const values = NDArray.zeros(weightsShape);\n    values.fill(this.value);\n    return values;\n  }\n}\n\nexport class NDArrayInitializer implements Initializer {\n  constructor(private ndarray: NDArray) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return this.ndarray;\n  }\n}\n\nexport class RandomNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomTruncatedNormalInitializer implements Initializer {\n  constructor(private mean = 0, private stdev = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev);\n  }\n}\n\nexport class RandomUniformInitializer implements Initializer {\n  constructor(private minval = -.05, private maxval = .05) {}\n\n  initialize(weightsShape: number[], inputUnits: number, outputUnits: number):\n      NDArray {\n    return NDArray.randUniform(weightsShape, this.minval, this.maxval);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport * as util from './util';\n\n/**\n * The interface for input providers.\n */\nexport interface InputProvider {\n  /**\n   * Get the next input as a copy. This is important because the data might\n   * get uploaded to the GPU and modify the original data.\n   * @param math NDArrayMath\n   */\n  getNextCopy(math: NDArrayMath): NDArray;\n  /**\n   * Dispose the input copy.\n   * @param math NDArrayMath\n   * @param copy The copy provided from getNextCopy\n   */\n  disposeCopy(math: NDArrayMath, copy: NDArray): void;\n}\n\n/**\n * A common interface for shuffled input provider builders. This returns\n * InputProviders that are synchronized.\n * @hidden\n */\nexport interface ShuffledInputProviderBuilder {\n  getInputProviders(): InputProvider[];\n}\n\n/**\n * @hidden\n */\nexport abstract class InMemoryShuffledInputProviderBuilder implements\n    ShuffledInputProviderBuilder {\n  protected shuffledIndices: Uint32Array;\n  protected numInputs: number;\n\n  protected idx = 0;\n  // Counter for how many times the current index has been called. Resets to 0\n  // when it reaches the number of inputs.\n  protected inputCounter = 0;\n  protected epoch = 0;\n\n  /**\n   * Constructs an `InMemoryShuffledInputProvider`. All of the inputs must be\n   * in memory.\n   * @param inputs All of the inputs, size: [number of inputs][number of\n   * examples].\n   */\n  constructor(protected inputs: NDArray[][]) {\n    this.shuffledIndices = util.createShuffledIndices(inputs[0].length);\n    this.numInputs = inputs.length;\n\n    // Make sure the number of examples in each input matches.\n    const numExamples = this.inputs[0].length;\n    for (let i = 0; i < this.numInputs; i++) {\n      util.assert(\n          this.inputs[i].length === numExamples,\n          'Number of examples must match across different inputs.');\n    }\n\n    // Make sure the shapes within inputs all match.\n    for (let i = 0; i < this.numInputs; i++) {\n      const inputShape = this.inputs[i][0].shape;\n      for (let j = 0; j < this.inputs[i].length; j++) {\n        util.assertShapesMatch(inputShape, this.inputs[i][j].shape);\n      }\n    }\n  }\n\n  protected getCurrentExampleIndex(): number {\n    const returnIdx = this.idx;\n\n    this.inputCounter++;\n    if (this.inputCounter >= this.numInputs) {\n      this.idx++;\n      this.inputCounter = 0;\n\n      if (this.idx >= this.inputs[0].length) {\n        this.idx = 0;\n        this.epoch++;\n      }\n    }\n    return returnIdx;\n  }\n\n  protected getNextInput(inputId: number): NDArray {\n    const currentExampleIndex = this.getCurrentExampleIndex();\n\n    return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]];\n  }\n\n  getEpoch() {\n    return this.epoch;\n  }\n\n  /**\n   * Returns input providers which shuffle the inputs and stay in sync.\n   */\n  getInputProviders(): InputProvider[] {\n    const inputProviders: InputProvider[] = [];\n\n    for (let i = 0; i < this.numInputs; i++) {\n      inputProviders.push(this.getInputProvider(i));\n    }\n    return inputProviders;\n  }\n\n  abstract getInputProvider(inputId: number): InputProvider;\n}\n\n/**\n * An in CPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * CPU and keeps them mutually in sync.\n */\nexport class InCPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return NDArray.like(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n\n/**\n * An in GPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the\n * GPU and keeps them mutually in sync. This is more performant than the CPU\n * version as textures will stay in memory, however this is more GPU memory\n * intensive as it keeps textures resident in GPU memory.\n */\nexport class InGPUMemoryShuffledInputProviderBuilder extends\n    InMemoryShuffledInputProviderBuilder {\n  getInputProvider(inputId: number) {\n    const shuffledInputProvider = this;\n\n    return {\n      getNextCopy(math: NDArrayMath): NDArray {\n        return math.clone(shuffledInputProvider.getNextInput(inputId));\n      },\n      disposeCopy(math: NDArrayMath, copy: NDArray) {\n        copy.dispose();\n      }\n    };\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/** A node's activation function and its derivative. */\nexport interface ActivationFunction {\n  output<T extends NDArray>(math: NDArrayMath, input: T): T;\n  der<T extends NDArray>(math: NDArrayMath, input: T, output: T): T;\n}\n\nexport class TanHFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.tanh(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      const ySquared = math.elementWiseMul(y, y);\n      // 1 - y^2.\n      return math.scalarMinusArray(Scalar.ONE, ySquared);\n    });\n  }\n}\n\nexport class ReLUFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.relu(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      return math.step(x);\n    });\n  }\n}\n\nexport class SigmoidFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.sigmoid(x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // y * (1 - y) = y - y^2\n      const ySquared = math.elementWiseMul(y, y);\n      return math.sub(y, ySquared);\n    });\n  }\n}\n\nexport class SquareFunc implements ActivationFunction {\n  output(math: NDArrayMath, x: NDArray) {\n    return math.scope(() => {\n      return math.elementWiseMul(x, x);\n    });\n  }\n\n  der(math: NDArrayMath, x: NDArray, y: NDArray) {\n    return math.scope(() => {\n      // dy/dx = 2*x.\n      return math.scalarTimesArray(Scalar.TWO, x);\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function assertConcat3DShapesMatch(\n    x1Shape: number[], x2Shape: number[], axis: number,\n    errorMessagePrefix = '') {\n  util.assert(\n      x1Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.');\n  util.assert(\n      x2Shape.length === 3,\n      errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.');\n\n  util.assert(\n      axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.');\n\n  for (let i = 0; i < 3; i++) {\n    util.assert(\n        (i === axis) || (x1Shape[i] === x2Shape[i]),\n        errorMessagePrefix +\n            `Shape (${x1Shape}) does not match (${x2Shape}) along ` +\n            `non-concatenated axis.`);\n  }\n}\n\nexport function computeConcat3DOutputShape(\n    x1Shape: number[], x2Shape: number[],\n    axis: number): [number, number, number] {\n  util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.');\n  util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.');\n\n  const outputShape = x1Shape.slice();\n  outputShape[axis] += x2Shape[axis];\n  return outputShape as [number, number, number];\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nexport function computeOutputShape3D(\n    inputShapeRowColDepth: [number, number, number], fieldSize: number,\n    depth: number, stride: number, zeroPad?: number): [number, number, number] {\n  if (zeroPad == null) {\n    zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride);\n  }\n  const inputRows = inputShapeRowColDepth[0];\n  const inputCols = inputShapeRowColDepth[1];\n  const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputRows),\n      `The output # of rows (${outputRows}) must be an integer. Change the ` +\n          `stride and/or zero pad parameters`);\n\n  const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1;\n  util.assert(\n      util.isInt(outputCols),\n      `The output # of columns (${outputCols}) must be an integer. Change ` +\n          `the stride and/or zero pad parameters`);\n\n  return [outputRows, outputCols, depth];\n}\n\nexport function computeDefaultPad(\n    inputShape: [number, number, number], fieldSize: number,\n    stride: number): number {\n  return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2);\n}\n\nexport function computeTexShapeFrom3D(\n    shapeRowColDepth: [number, number, number]): [number, number] {\n  return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]];\n}\n\nexport function computeWeightsShape4D(\n    inputDepth: number, outputDepth: number,\n    fSize: number): [number, number, number, number] {\n  return [fSize, fSize, inputDepth, outputDepth];\n}\n\nexport function computeWeightsTexShape(\n    inputDepth: number, outputDepth: number,\n    fieldSize: number): [number, number] {\n  return [fieldSize * fieldSize * inputDepth, outputDepth];\n}\n\nexport function computeBiasesTexShape(outputDepth: number): [number, number] {\n  return [1, outputDepth];\n}\n\nexport function computeDilatedRC(\n    rc: [number, number], origStride: number): [number, number] {\n  const rowsDilated = (rc[0] - 1) * origStride + 1;\n  const colsDilated = (rc[1] - 1) * origStride + 1;\n  return [rowsDilated, colsDilated];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function validateShapes(\n    sourceSize: [number, number], destSize: [number, number]) {\n  const srcArea = sourceSize[0] * sourceSize[1];\n  const dstArea = destSize[0] * destSize[1];\n  if (srcArea !== dstArea) {\n    const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']';\n    const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']';\n    throw new Error(\n        'copy2D shapes have different areas:\\n  sourceSize ' + srcStr +\n        ', area ' + srcArea + '\\n  destSize ' + dstStr + ', area ' + dstArea);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from './math';\nimport {NDArray, Scalar} from './ndarray';\n\n/**\n * An error function and its derivative.\n */\nexport interface ElementWiseCostFunction {\n  cost<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  der<T extends NDArray>(math: NDArrayMath, x1: T, x2: T): T;\n  dispose(): void;\n}\n\nexport class SquareCostFunc implements ElementWiseCostFunction {\n  private halfOne = Scalar.new(0.5);\n\n  cost(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    const diff = math.sub(x1, x2);\n    const diffSquared = math.elementWiseMul(diff, diff);\n    const result = math.scalarTimesArray(this.halfOne, diffSquared);\n\n    diff.dispose();\n    diffSquared.dispose();\n\n    return result;\n  }\n\n  der(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray {\n    return math.sub(x1, x2);\n  }\n\n  dispose() {\n    this.halfOne.dispose();\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2d_util from './copy2d_util';\n\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport type ScopeResult = NDArray[]|NDArray|void;\n\nexport abstract class NDArrayMath {\n  private ndarrayScopes: NDArray[][] = [];\n  private activeScope: NDArray[];\n\n  private ndarraysToKeep: NDArray[][] = [];\n  private activeScopeNDArraysToKeep: NDArray[] = [];\n\n  /**\n   * @param safeMode In safe mode, you must use math operations inside\n   * a math.scope() which will automatically clean up intermediate NDArrays.\n   */\n  constructor(private safeMode: boolean) {}\n\n  /**\n   * Create a new math scope. Put chained math operations inside a scope\n   * function closure so that the library automatically cleans up NDArrays\n   * from intermediate math operations. You must create a scope in safe mode\n   * to call math operations. If a result is returned from the scope, it will\n   * also be tracked, which means there must be yet another wrapping scope.\n   * @param scopeFn The function to execute with chained math operations.\n   */\n  scope<T extends ScopeResult>(\n      scopeFn:\n          (keep: <T1 extends NDArray>(ndarray: T1) => T1,\n           track: <T2 extends NDArray>(ndarray: T2) => T2) => T) {\n    this.startScope();\n\n    const keepFn = <T extends NDArray>(ndarray: T): T => this.keep(ndarray);\n    const trackFn = <T extends NDArray>(ndarray: T): T => this.track(ndarray);\n    const result = scopeFn(keepFn, trackFn);\n\n    this.endScope(result);\n\n    return result;\n  }\n\n  /**\n   * Start a scope. Use this with endScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  startScope() {\n    const newScope: NDArray[] = [];\n    this.ndarrayScopes.push(newScope);\n    this.activeScope = newScope;\n\n    const newNDArraysToKeep: NDArray[] = [];\n    this.ndarraysToKeep.push(newNDArraysToKeep);\n    this.activeScopeNDArraysToKeep = newNDArraysToKeep;\n  }\n\n  /**\n   * End a scope. Use this with startScope() to achieve the same functionality\n   * as scope() without the need for a function closure.\n   */\n  endScope(result: ScopeResult) {\n    // Dispose the current scope.\n    for (let i = 0; i < this.activeScope.length; i++) {\n      const ndarray = this.activeScope[i];\n\n      if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) ||\n          (result != null && result instanceof NDArray &&\n           ndarray.getData() === (result as NDArray).getData())) {\n        continue;\n      }\n      ndarray.dispose();\n    }\n\n    // Pop the current scope.\n    this.ndarrayScopes.pop();\n    this.activeScope = this.ndarrayScopes.length === 0 ?\n        null! :\n        this.ndarrayScopes[this.ndarrayScopes.length - 1];\n\n    // Track the current result in the parent scope.\n    if (result instanceof NDArray &&\n        !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) {\n      this.track(result);\n    } else if (Array.isArray(result)) {\n      result.forEach(r => {\n        if (r instanceof NDArray &&\n            !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) {\n          this.track(r);\n        }\n      });\n    }\n\n    this.ndarraysToKeep.pop();\n    this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ?\n        null! :\n        this.ndarraysToKeep[this.ndarraysToKeep.length - 1];\n  }\n\n  private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) {\n    for (let i = 0; i < ndarrayList.length; i++) {\n      if (ndarrayList[i].getData() === ndarray.getData()) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Keeps an NDArray in the current scope from being disposed automatically.\n   * @param result The NDArray to keep from being disposed.\n   */\n  keep<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScopeNDArraysToKeep.push(result);\n    return result;\n  }\n\n  /**\n   * Tracks an NDArray in the current scope to be automatically cleaned up when\n   * the current scope ends, and returns the value.\n   * @param result The NDArray to track in the current scope.\n   */\n  track<T extends NDArray>(result: T): T {\n    if (this.activeScope == null) {\n      if (this.safeMode) {\n        throw new Error(\n            'You are using math in safe mode. Enclose all ' +\n            'math.method() calls inside a scope: ' +\n            'math.scope(() => {math.method();...}) to avoid memory ' +\n            'leaks.');\n      }\n      return result;\n    }\n    this.activeScope.push(result);\n    return result;\n  }\n\n  /**\n   * Computes the dot product of two matrices, A * B. These must be matrices,\n   * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct\n   * in other cases.\n   * @param a First matrix in dot product operation.\n   * @param b Second matrix in dot product operation.\n   * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will\n   * compute A^T * B.\n   * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will\n   * compute A * B^T.\n   */\n  matMul(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const innerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const innerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1];\n\n    util.assert(\n        a.rank === 2 && b.rank === 2,\n        `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` +\n            `and ${b.rank}.`);\n\n    util.assert(\n        innerShapeA === innerShapeB,\n        `Error in matMul: inner shapes (${innerShapeA}) and (` +\n            `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` +\n            `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` +\n            ` and ${MatrixOrientation[bOrientation]} must match.`);\n\n    return this.track(this.matMulInternal(a, b, aOrientation, bOrientation));\n  }\n  protected abstract matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D;\n\n  /**\n   * Computes the dot product of a vector and a matrix, v * B.\n   * @param v The vector in dot product operation.\n   * @param matrix The matrix in dot product operation.\n   */\n  vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: first input must be rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: second input must be rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[0],\n        `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `rank ${matrix.rank}.`);\n\n    return this.matMul(v.as2D(1, v.size), matrix).as1D();\n  }\n\n  /**\n   * Computes the dot product of a matrix and vector, A * v.\n   * @param matrix The matrix in dot product operation.\n   * @param v The vector in dot product operation.\n   */\n  matrixTimesVector(matrix: Array2D, v: Array1D): Array1D {\n    util.assert(\n        v.rank === 1,\n        `Error in vectorTimesMatrix: second input must rank 1, but got ` +\n            `rank ${v.rank}.`);\n    util.assert(\n        matrix.rank === 2,\n        `Error in vectorTimesMatrix: first input must be a rank 2, but got ` +\n            `rank ${matrix.rank}.`);\n    util.assert(\n        v.size === matrix.shape[1],\n        `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` +\n            `must match inner dimension of second rank 2 input, but got ` +\n            `shape ${matrix.shape}.`);\n\n    return this.matMul(matrix, v.as2D(v.size, 1)).as1D();\n  }\n\n  /**\n   * Computes the dot product of two vectors, v1 * v2.\n   * @param v1 The first vector in the dot product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  dotProduct(v1: Array1D, v2: Array1D): Scalar {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in dotProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n    util.assert(\n        v1.size === v2.size,\n        `Error in dotProduct: size of inputs (${v1.size}) and (` +\n            `${v2.size}) must match.`);\n    return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar();\n  }\n\n  /**\n   * Computes the outer product of two vectors, v1 and v2.\n   * @param v1 The first vector in the outer product operation.\n   * @param v2 The second vector in the dot product operation.\n   */\n  outerProduct(v1: Array1D, v2: Array1D): Array2D {\n    util.assert(\n        v1.rank === 1 && v2.rank === 1,\n        `Error in outerProduct: inputs must be rank 1, but got ranks ` +\n            `${v1.rank} and ${v2.rank}.`);\n\n    return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size));\n  }\n\n  ///////////////\n  // Shape ops //\n  ///////////////\n\n  /**\n   * Clones an NDArray of any shape.\n   * @param ndarray The NDArray to clone.\n   */\n  clone<T extends NDArray>(ndarray: T): T {\n    return this.track(this.cloneInternal(ndarray));\n  }\n  protected abstract cloneInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Reshapes an NDArray to a new shape. The size of the input NDArray must\n   * match the size of the requested shape.\n   * @param ndarray The input NDArray.\n   * @param newShape The new shape to reshape the NDArray to. Must be the same\n   * size as the NDArray.\n   */\n  reshape<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    util.assert(\n        ndarray.size === util.sizeFromShape(newShape),\n        `Error in reshape: old size ${ndarray.size} must match new size ` +\n            `${util.sizeFromShape(newShape)}.`);\n    return this.track(this.reshapeInternal<T1, T2>(ndarray, newShape));\n  }\n  protected abstract reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2;\n\n  /**\n   * Extracts a slice from a matrix. The operation extraces a slice from input\n   * that starts at coordinates `begin` and is of size `size`.\n   * @param input The input matrix to slice from.\n   * @param begin The 2D coordinates in the input matrix to start the slice\n   * from.\n   * @param size The sice of the 2D window to slice.\n   */\n  slice2D(input: Array2D, begin: [number, number], size: [number, number]):\n      Array2D {\n    util.assert(\n        begin[0] + size[0] <= input.shape[0] &&\n            begin[1] + size[1] <= input.shape[1],\n        `Error in slice2D: requested start position ${begin} and size ` +\n            `${size} would overflow input of shape ${input.shape}.`);\n    return this.track(this.slice2DInternal(input, begin, size));\n  }\n  protected abstract slice2DInternal(\n      input: Array2D, begin: [number, number], size: [number, number]): Array2D;\n\n  /**\n   * Copies a window from the `source` matrix starting at `sourceBegin` and is\n   * of size `sourceSize` to a window in the `dest` matrix starting at\n   * `destBegin` and is of size `destSize`/\n   * @param source The source matrix to copy from.\n   * @param sourceBegin The coordinates to start the copy from.\n   * @param sourceSize The size of the copy window.\n   * @param dest The destination matrix to copy to.\n   * @param destBegin The coordinates in `dest` to copy to.\n   * @param destSize The size of the destination window.\n   */\n  copy2D(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]) {\n    util.assert(\n        sourceBegin[0] + sourceSize[0] <= source.shape[0] &&\n            sourceBegin[1] + sourceSize[1] <= source.shape[1],\n        `Error in copy2D: requested source start position ${sourceBegin} ` +\n            `and source size ${sourceSize} would overflow source NDArray` +\n            `of shape ${source.shape}.`);\n    util.assert(\n        destBegin[0] + destSize[0] <= dest.shape[0] &&\n            destBegin[1] + destSize[1] <= dest.shape[1],\n        `Error in copy2D: requested dest start position ${destBegin} ` +\n            `and source size ${destSize} would overflow dest NDArray of` +\n            `shape ${dest.shape}.`);\n    copy2d_util.validateShapes(sourceSize, destSize);\n\n    return this.copy2DInternal(\n        source, sourceBegin, sourceSize, dest, destBegin, destSize);\n  }\n  protected abstract copy2DInternal(\n      source: Array2D, sourceBegin: [number, number],\n      sourceSize: [number, number], dest: Array2D, destBegin: [number, number],\n      destSize: [number, number]): void;\n\n  /**\n   * Concatenates two 3D ndarrays along a given axis.\n   *\n   * For example, if:\n   * A: shape(2, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *\n   * B: shape(2, 1, 3) = | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * C = concat3D(A, B, axis)\n   *\n   * if axis = 0:\n   * C: shape(4, 1, 3) = | r1, g1, b1 |\n   *                     | r2, g2, b2 |\n   *                     | r3, g3, b3 |\n   *                     | r4, g4, b4 |\n   *\n   * if axis = 1:\n   * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |\n   *                     | r2, g2, b2, r4, g4, b4 |\n   *\n   * if axis = 2:\n   * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |\n   *                      | r2, g2, b2, r4, g4, b4 |\n   *\n   * @param ndarray1 The first array to concat.\n   * @param ndarray2 The second array to conat.\n   * @param axis The axis to concate along.\n   */\n  concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D {\n    concat3d_util.assertConcat3DShapesMatch(\n        ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: ');\n    return this.track(this.concat3DInternal(ndarray1, ndarray2, axis));\n  }\n  protected abstract concat3DInternal(\n      ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D;\n\n  ///////////////////\n  // Reduction ops //\n  ///////////////////\n\n  /**\n   * Computes the the log(sum(e ^ x)) for each x in the input ndarray.\n   * @param ndarray The input NDArray to compute the logSumExp over.\n   */\n  logSumExp(ndarray: NDArray): Scalar {\n    return this.track(this.logSumExpInternal(ndarray));\n  }\n  protected abstract logSumExpInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the sum of all the entries in the input NDArray.\n   * @param ndarray The input NDArray to compute the sum over.\n   */\n  sum(ndarray: NDArray): Scalar {\n    return this.track(this.sumInternal(ndarray));\n  }\n  protected abstract sumInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the minimum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMin(ndarray: NDArray): Scalar {\n    return this.track(this.argMinInternal(ndarray));\n  }\n  protected abstract argMinInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the flattened index of the maximum element in the ndarray.\n   * @param ndarray The input NDArray.\n   */\n  argMax(ndarray: NDArray): Scalar {\n    return this.track(this.argMaxInternal(ndarray));\n  }\n  protected abstract argMaxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0.\n   * @param x1 The first input NDArray.\n   * @param x2 The second input NDArray.\n   */\n  argMaxEquals(x1: NDArray, x2: NDArray): Scalar {\n    util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: ');\n    return this.track(this.argMaxEqualsInternal(x1, x2));\n  }\n  protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar;\n\n  /**\n   * Computes the top K values and flattened indices.\n   * @param ndarray The input NDArray.\n   * @param k How many top values to compute.\n   */\n  topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} {\n    util.assert(\n        k <= ndarray.size,\n        `Error in topK: k value (${k}) must be less than size of input ` +\n            `ndarray, got shape ${ndarray.shape}.`);\n    const result = this.topKInternal(ndarray, k);\n    this.track(result.values);\n    this.track(result.indices);\n    return result;\n  }\n  protected abstract topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D};\n\n  /**\n   * Computes the minimum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  min(ndarray: NDArray): Scalar {\n    return this.track(this.minInternal(ndarray));\n  }\n  protected abstract minInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the maximum value from the input.\n   * @param ndarray The input NDArray.\n   */\n  max(ndarray: NDArray): Scalar {\n    return this.track(this.maxInternal(ndarray));\n  }\n  protected abstract maxInternal(ndarray: NDArray): Scalar;\n\n  /**\n   * Computes the softmax normalized vector from the input vector.\n   * @param x The input vector.\n   */\n  softmax(x: Array1D): Array1D {\n    return this.scope(() => {\n      // Do it in log space for numerical stability.\n      // exp(X - logSumExp(X))\n      const lse = this.logSumExp(x);\n      const logResult = this.arrayMinusScalar(x, lse);\n      return this.exp(logResult);\n    });\n  }\n\n  //////////////////////\n  // Element-wise ops //\n  //////////////////////\n\n  /**\n   * Switches dimensions of the input NDArray.\n   * @param a The input NDArray.\n   * @param newDim The new indices that define which shapes values to switch.\n   */\n  switchDim<T extends NDArray>(a: T, newDim: number[]): T {\n    util.assert(\n        a.rank === newDim.length,\n        `Error in switchDim: length of input shape ${a.shape} ` +\n            `must match size of newDim array ${newDim}.`);\n    return this.track(this.switchDimInternal(a, newDim));\n  }\n  protected abstract switchDimInternal<T extends NDArray>(\n      a: T, newDim: number[]): T;\n\n  /**\n   * Computes a scalar plus NDArray, c + A.\n   * @param c The scalar c in c + A.\n   * @param a The NDArray A in c + A.\n   */\n  scalarPlusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarPlusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarPlusArrayInternal(c, a));\n  }\n  protected abstract scalarPlusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, c - A.\n   * @param c The scalar c in c - A.\n   * @param a The NDArray A in c - A.\n   */\n  scalarMinusArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarMinusArray: first argument must be rank 0, but got ` +\n            `rank ${c.rank}.`);\n    return this.track(this.scalarMinusArrayInternal(c, a));\n  }\n  protected abstract scalarMinusArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes a scalar minus NDArray, A - c.\n   * @param a The NDArray A in A - c.\n   * @param c The scalar c in A - c.\n   */\n  arrayMinusScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayMinusScalar: second argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.arrayMinusScalarInternal(a, c));\n  }\n  protected abstract arrayMinusScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes -1 * A element-wise.\n   * @param a The input array.\n   */\n  neg<T extends NDArray>(a: T): T {\n    return this.track(this.negInternal(a));\n  }\n  protected abstract negInternal<T extends NDArray>(a: T): T;\n\n  /**\n   * Adds two NDArrays element-wise, A + B. Inputs must be the same shape.\n   * @param a The first NDArray to add element-wise.\n   * @param b The second NDArray to add element-wise.\n   */\n  add<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in add: ');\n    return this.track(this.addInternal(a, b));\n  }\n  protected abstract addInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape.\n   * @param a The first NDArray to subtract element-wise.\n   * @param b The second NDArray to subtract element-wise.\n   */\n  sub<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in sub: ');\n    return this.track(this.subInternal(a, b));\n  }\n  protected abstract subInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must\n   * be the same shape.\n   * @param a The first NDArray to multiply element-wise.\n   * @param b The second NDArray to multiply element-wise.\n   */\n  elementWiseMul<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: ');\n    return this.track(this.elementWiseMulInternal(a, b));\n  }\n  protected abstract elementWiseMulInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be\n   * the same shape.\n   * @param a The first NDArray to divide element-wise.\n   * @param b The second NDArray to divide element-wise.\n   */\n  divide<T extends NDArray>(a: T, b: T): T {\n    util.assertShapesMatch(a.shape, b.shape, 'Error in divide: ');\n    return this.track(this.divideInternal(a, b));\n  }\n  protected abstract divideInternal<T extends NDArray>(a: T, b: T): T;\n\n  /**\n   * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c /\n   * A.\n   * @param c The scalar value in c / A.\n   * @param a The NDArray value in c / A.\n   */\n  scalarDividedByArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in scalarDividedByArray: first argument must be rank 0, but ` +\n            `got NDArray of rank ${c.rank}.`);\n    return this.track(this.scalarDividedByArrayInternal(c, a));\n  }\n  protected abstract scalarDividedByArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A /\n   * c.\n   * @param a The NDArray value in A / c.\n   * @param c The scalar value in A / c.\n   */\n  arrayDividedByScalar<T extends NDArray>(a: T, c: Scalar): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: second argument must be rank 0, ` +\n            `but got NDArray of rank ${c.rank}.`);\n    return this.track(this.arrayDividedByScalarInternal(a, c));\n  }\n  protected abstract arrayDividedByScalarInternal<T extends NDArray>(\n      a: T, c: Scalar): T;\n\n  /**\n   * Computes exponential of the input NDArray element-wise. y = e ^ x\n   * @param ndarray The input NDArray.\n   */\n  exp<T extends NDArray>(ndarray: T): T {\n    return this.track(this.expInternal(ndarray));\n  }\n  protected abstract expInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes natural logarithm of the input NDArray element-wise. y = ln(x)\n   * @param ndarray The input NDArray.\n   */\n  log<T extends NDArray>(ndarray: T): T {\n    return this.track(this.logInternal(ndarray));\n  }\n  protected abstract logInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes rectified linear element-wise, max(x, 0).\n   * @param ndarray The input NDArray.\n   */\n  relu<T extends NDArray>(ndarray: T): T {\n    return this.track(this.reluInternal(ndarray));\n  }\n  protected abstract reluInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)).\n   * @param ndarray The input NDArray.\n   */\n  sigmoid<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sigmoidInternal(ndarray));\n  }\n  protected abstract sigmoidInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes hyperbolic tangent of the input NDArray element-wise.\n   * @param ndarray The input NDArray.\n   */\n  tanh<T extends NDArray>(ndarray: T): T {\n    return this.track(this.tanhInternal(ndarray));\n  }\n  protected abstract tanhInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes sin of the input NDArray element-wise, y = sin(x).\n   * @param ndarray The input NDArray.\n   */\n  sin<T extends NDArray>(ndarray: T): T {\n    return this.track(this.sinInternal(ndarray));\n  }\n  protected abstract sinInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <=\n   * 0\n   * @param ndarray The input NDArray.\n   */\n  step<T extends NDArray>(ndarray: T): T {\n    return this.track(this.stepInternal(ndarray));\n  }\n  protected abstract stepInternal<T extends NDArray>(ndarray: T): T;\n\n  /**\n   * Computes a scaled array add operation, c1 * A + c2 * B.\n   * @param c1 The first scalar in the scaled array add computation.\n   * @param a The first NDArray in the scaled array add computation.\n   * @param c2 The second scalar in the scaled array add computation.\n   * @param cb The second NDArray in the scaled array add computation.\n   */\n  scaledArrayAdd<T extends NDArray>(c1: Scalar, a: T, c2: Scalar, b: T): T {\n    util.assert(\n        c1.size === 1,\n        `Error in scaledArrayAdd: first argument must rank 0, but got ` +\n            ` rank ${c1.rank}.`);\n    util.assert(\n        c2.size === 1,\n        `Error in scaledArrayAdd: third argument must be rank 0, but got ` +\n            `NDArray of rank ${c2.rank}.`);\n    util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: ');\n\n    return this.track(this.scaledArrayAddInternal(c1, a, c2, b));\n  }\n  protected abstract scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T): T;\n\n  /**\n   * Computes a scalar times array operation broadcasted over the NDArray, c *\n   * A.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  scalarTimesArray<T extends NDArray>(c: Scalar, a: T): T {\n    util.assert(\n        c.size === 1,\n        `Error in arrayDividedByScalar: first argument must be rank 0, but ` +\n            `got rank ${c.rank}.`);\n    return this.track(this.scalarTimesArrayInternal(c, a));\n  }\n  protected abstract scalarTimesArrayInternal<T extends NDArray>(\n      c: Scalar, a: T): T;\n\n  /**\n   * Computes an element-wise broadcasted multiplication of two matrices A and\n   * B. Will return a new matrix that is the max of A and B, where the smaller\n   * matrix will broadcast over the larger matrix.\n   * @param c The scalar in the operation.\n   * @param A the NDArray in the operation that will be broadcasted over.\n   */\n  elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D {\n    util.assert(\n        a.rank === 2,\n        `Error in elementWiseMulBroadcast: first argument must be ` +\n            `rank 2, but got rank ${a.rank}.`);\n    util.assert(\n        b.rank === 2,\n        `Error in elementWiseMulBroadcast: second argument must be ` +\n            `rank 2, but got rank ${b.rank}.`);\n    return this.track(this.elementWiseMulBroadcastInternal(a, b));\n  }\n  protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D):\n      Array2D;\n\n  /////////////////////\n  // Convolution ops //\n  /////////////////////\n\n  /**\n   * Computes a 2D convolution over the input x.\n   * @param x The input image, must be rank 3, of shape [rows, cols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param zeroPad The zero padding of each side of the input NDArray. Will pad\n   * equally on all sides.\n   */\n  conv2d(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2d: weights must be rank 4, but got rank ` +\n            `${weights.rank}.`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2d: biases must be rank 1, but got rank ` +\n              `${biases.rank}.`);\n    }\n\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2d: depth of input (${x.shape[2]}) must match  ` +\n            `input depth for weights ${weights.shape[2]}.`);\n\n\n    return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad));\n  }\n  protected abstract conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D;\n\n  /**\n   * Computes the backprop of a 2D convolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param stride The stride of the original convolution.\n   * @param pad The padding of the original convolution.\n   */\n  conv2dBackProp(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dBackProp: x must be rank 3, but got shape ` +\n            `${x.shape}.`);\n    util.assert(\n        dy.rank === 3,\n        `Error in conv2dBackProp: dy must be rank 3, but got shape ` +\n            `${dy.shape}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dBackProp: weights must be rank 4, but got shape ` +\n            `${weights.shape}.`);\n    util.assert(\n        x.shape[2] === weights.shape[2],\n        `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` +\n            `match input depth for weights (${weights.shape[2]}.`);\n    util.assert(\n        dy.shape[2] === weights.shape[3],\n        `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` +\n            `match output depth for weights (${weights.shape[3]}).`);\n\n    const backpropResult =\n        this.conv2dBackPropInternal(x, dy, weights, stride, pad);\n\n    this.track(backpropResult.db);\n    this.track(backpropResult.dw);\n    this.track(backpropResult.dx);\n\n    return backpropResult;\n  }\n  protected abstract conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D};\n\n  /**\n   * Computes the transposed 2D convolution of an image, also known as a\n   * deconvolution.\n   * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1].\n   * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1,\n   * depth2].\n   * @param biases Optional biases NDArray, must be rank 1 of shape [depth2].\n   * @param stride The stride of the convolution.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  conv2dTranspose(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in conv2dTranspose: x must be rank 3, but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        weights.rank === 4,\n        `Error in conv2dTranspose: weights must be rank 4, but got ` +\n            `rank ${weights.rank}`);\n    if (biases != null) {\n      util.assert(\n          biases.rank === 1,\n          `Error in conv2dTranspose: biases must be rank 1, but got ' +\n              'rank ${biases.rank}.`);\n    }\n    util.assert(\n        x.shape[2] === weights.shape[3],\n        `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` +\n            `match input depth for weights ${weights.shape[3]}.`);\n\n    return this.track(\n        this.conv2dTransposeInternal(x, weights, biases, stride, pad));\n  }\n  protected abstract conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D max pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.');\n    return this.track(this.maxPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the backprop of a max pool.\n   * @param dy The dy error.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  maxPoolBackprop(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    util.assert(\n        dy.rank === 3,\n        `Error in maxPoolBackprop: dy must be rank 3 but got rank ` +\n            `${dy.rank}.`);\n    util.assert(\n        x.rank === 3,\n        `Error in maxPoolBackprop: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n\n    return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad));\n  }\n  protected abstract maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D;\n\n  /**\n   * Computes the 2D min pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in minPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.minPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /**\n   * Computes the 2D average pooling of an image.\n   * @param x The input image, must be rank 3.\n   * @param fSize The field size of the max pool.\n   * @param stride The stride of the max pool.\n   * @param pad The padding of each side of the input NDArray. Will pad equally\n   * on all sides.\n   */\n  avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`);\n    return this.track(this.avgPoolInternal(x, fSize, stride, pad));\n  }\n  protected abstract avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D;\n\n  /*\n   * Bilinear resize a 3D array per each channel to a new 2D shape.\n   * @param x The input Array3D.\n   * @param newShape2D The new shape to resize the Array3D to. Each channel is\n   * resized individually.\n   * @param alignCorners An optional bool. Defaults to False. If true, rescale\n   * input by (new_height - 1) / (height - 1), which exactly aligns the 4\n   * corners of images and resized images. If false, rescale by new_height /\n   * height. Treat similarly the width dimension.\n   */\n  resizeBilinear3D(\n      x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`);\n    util.assert(\n        newShape2D.length === 2,\n        `Error in resizeBilinear3D: new shape must 2D, but got shape ` +\n            `${newShape2D}.`);\n    return this.track(\n        this.resizeBilinear3DInternal(x, newShape2D, alignCorners));\n  }\n  protected abstract resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D;\n\n  /**\n   * Batch normalization 3D. Mean, variance, scale, and offset can be of two\n   * shapes: 1) The same shape as the input: an Array3D. 2) In the common case,\n   * the depth dimension is the last dimension of x, so the values would be an\n   * Array1D of shape [depth].\n   * @param x The input NDArray.\n   * @param mean A mean NDArray.\n   * @param variance A variance NDArray.\n   * @param varianceEpsilon A small float number to avoid dividing by 0.\n   * @param scale A scale NDArray.\n   * @param offset An offset NDArray.\n   */\n  batchNormalization3D(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    util.assert(\n        x.rank === 3,\n        `Error in batchNormalization3D: x must be rank 3 but got rank ` +\n            `${x.rank}.`);\n    util.assert(\n        mean.rank === 3 || mean.rank === 1,\n        `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` +\n            `got rank ${mean.rank}.`);\n    util.assert(\n        variance.rank === 3 || variance.rank === 1,\n        `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` +\n            `but got rank ${variance.rank}.`);\n    if (scale != null) {\n      util.assert(\n          scale.rank === 3 || scale.rank === 1,\n          `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` +\n              `but got rank ${scale!.rank}.`);\n    }\n    if (offset != null) {\n      util.assert(\n          offset.rank === 3 || offset.rank === 1,\n          `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` +\n              `but got rank ${offset!.rank}.`);\n    }\n\n    return this.track(this.batchNormalization3DInternal(\n        x, mean, variance, varianceEpsilon, scale, offset));\n  }\n  protected abstract batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D;\n}\n\nexport enum MatrixOrientation {\n  REGULAR,\n  TRANSPOSED\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../math/conv_util';\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as copy2D_util from './copy2d_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\n\nexport class NDArrayMathCPU extends NDArrayMath {\n  constructor(safeMode = false) {\n    super(safeMode);\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    return NDArray.make<T>(\n        ndarray.shape, {values: new Float32Array(ndarray.getValues())});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    return this.cloneInternal(ndarray).reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = Array2D.zeros(sizeRowCol);\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol);\n    const srcValues = source.getValues();\n    const dstValues = dest.getValues();\n    const n = sourceSizeRowCol[0] * sourceSizeRowCol[1];\n    for (let i = 0; i < n; ++i) {\n      const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]);\n      const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]);\n      const srcOff = srcRow * source.shape[1] + srcCol;\n      const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]);\n      const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]);\n      const dstOff = dstRow * dest.shape[1] + dstCol;\n      dstValues[dstOff] = srcValues[srcOff];\n    }\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const outputShape =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const values = NDArray.zeros<Array3D>(outputShape);\n\n    for (let i = 0; i < outputShape[0]; i++) {\n      for (let j = 0; j < outputShape[1]; j++) {\n        for (let k = 0; k < outputShape[2]; k++) {\n          // Shader begins.\n          const index: [number, number, number] = [i, j, k];\n          let value: number;\n          if (index[axis] < x1.shape[axis]) {\n            value = x1.get(i, j, k);\n          } else {\n            index[axis] -= x1.shape[axis];\n            const [i2, j2, k2] = index;\n            value = x2.get(i2, j2, k2);\n          }\n\n          values.set(value, i, j, k);\n        }\n      }\n    }\n\n    return values;\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const resultValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < resultValues.length; ++i) {\n      resultValues[i] = cVal + aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: resultValues});\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    const cValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    const c1Val = c1.get();\n    const c2Val = c2.get();\n    for (let i = 0; i < cValues.length; ++i) {\n      cValues[i] = c1Val * aValues[i] + c2Val * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: cValues});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cVal = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cVal * aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    const negA = this.negInternal(a);\n    const result = this.scalarPlusArrayInternal(c, negA);\n\n    negA.dispose();\n\n    return result;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    const negC = this.negInternal(c);\n    const result = this.scalarPlusArrayInternal(negC, a);\n\n    negC.dispose();\n\n    return result;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a);\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.ONE, b);\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.scaledArrayAddInternal<T>(Scalar.ONE, a, Scalar.NEG_ONE, b);\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR,\n      bOrientation = MatrixOrientation.REGULAR): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n\n    const leftDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const rightDim =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n\n    const normalGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(i, j);\n    const transposedGetter = (matrix: Array2D, i: number, j: number) =>\n        matrix.get(j, i);\n\n    const aGetter = (aOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const bGetter = (bOrientation === MatrixOrientation.REGULAR) ?\n        normalGetter :\n        transposedGetter;\n    const values = new Float32Array(leftDim * rightDim);\n    let index = 0;\n\n    for (let i = 0; i < leftDim; ++i) {\n      for (let j = 0; j < rightDim; ++j) {\n        let sum = 0;\n        for (let k = 0; k < sharedDim; ++k) {\n          // TODO: optimize CPU matmul.\n          sum += aGetter(a, i, k) * bGetter(b, k, j);\n        }\n        values[index++] = sum;\n      }\n    }\n    return Array2D.new([leftDim, rightDim], values);\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] * bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    const maxRow = Math.max(a.shape[0], b.shape[0]);\n    const maxCol = Math.max(a.shape[1], b.shape[1]);\n\n    const values = new Float32Array(maxRow * maxCol);\n    let index = 0;\n    for (let row = 0; row < maxRow; row++) {\n      for (let col = 0; col < maxCol; col++) {\n        values[index++] = a.get(row % a.shape[0], col % a.shape[1]) *\n            b.get(row % b.shape[0], col % b.shape[1]);\n      }\n    }\n    return Array2D.new([maxRow, maxCol], values);\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const bValues = b.getValues();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / bValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = cValue / aValues[i];\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    const newValues = new Float32Array(a.size);\n    const aValues = a.getValues();\n    const cValue = c.get();\n    for (let i = 0; i < aValues.length; ++i) {\n      newValues[i] = aValues[i] / cValue;\n    }\n    return NDArray.make<T>(a.shape, {values: newValues});\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    let sum = 0;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      sum += values[i];\n    }\n    return Scalar.new(sum);\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    let min = Number.MAX_VALUE;\n    let minIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n        minIndex = i;\n      }\n    }\n    return Scalar.new(minIndex);\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    let max = Number.NEGATIVE_INFINITY;\n    let maxIndex = -1;\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n    return Scalar.new(maxIndex);\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    const argMax1 = this.argMaxInternal(x1).get();\n    const argMax2 = this.argMaxInternal(x2).get();\n    if (isNaN(argMax1) || isNaN(argMax2)) {\n      return Scalar.new(NaN);\n    }\n    return Scalar.new(+(argMax1 === argMax2));\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    const values = ndarray.getValues();\n    const valuesAndIndices: Array<{value: number, index: number}> = [];\n    for (let i = 0; i < values.length; i++) {\n      valuesAndIndices.push({value: values[i], index: i});\n    }\n    valuesAndIndices.sort((a, b) => {\n      return b.value - a.value;\n    });\n    const topkValues = new Float32Array(k);\n    const topkIndices = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n      topkValues[i] = valuesAndIndices[i].value;\n      topkIndices[i] = valuesAndIndices[i].index;\n    }\n    return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)};\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let min = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value < min) {\n        min = value;\n      }\n    }\n    return Scalar.new(min);\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const values = ndarray.getValues();\n    let max = values[0];\n    for (let i = 1; i < values.length; ++i) {\n      const value = values[i];\n      if (isNaN(value)) {\n        return Scalar.new(NaN);\n      }\n      if (value > max) {\n        max = value;\n      }\n    }\n    return Scalar.new(max);\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      newValues[i] = Math.exp(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const values = ndarray.getValues();\n    const newValues = new Float32Array(values.length);\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      newValues[i] = Math.log(value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: newValues});\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const xMax = this.max(ndarray);\n    const a = this.arrayMinusScalar(ndarray, xMax);\n    const b = this.exp(a);\n    const c = this.sum(b);\n    const d = this.log(c);\n    const result = this.add(xMax, d);\n\n    xMax.dispose();\n    a.dispose();\n    b.dispose();\n    c.dispose();\n    d.dispose();\n\n    return result;\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.max(0, values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = 1 / (1 + Math.exp(-values[i]));\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = util.tanh(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      resultValues[i] = Math.sin(values[i]);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const resultValues = new Float32Array(ndarray.size);\n    const values = ndarray.getValues();\n    for (let i = 0; i < values.length; ++i) {\n      const value = values[i];\n      resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value);\n    }\n    return NDArray.make<T>(ndarray.shape, {values: resultValues});\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      pad: number): Array3D {\n    const [xRows, xCols, inputDepth] = x.shape;\n    const fieldSize = weights.shape[0];\n    const outputDepth = weights.shape[3];\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fieldSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fieldSize + xCCorner);\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              for (let d1 = 0; d1 < inputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight = weights.get(wR, wC, d1, d2);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = (biases != null) ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad);\n    return {dx, db, dw};\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const fSize = weights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR - pad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / origStride));\n        const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride);\n\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC - pad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / origStride));\n          const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride);\n\n          let dotProd = 0;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR * origStride - xRCorner;\n\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC * origStride - xCCorner;\n\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          const bias = biases != null ? biases.get(d2) : 0;\n          y.set(dotProd + bias, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  /**\n   * image is of shape [r, c, d1].\n   * weights is of shape [F, F, d1, d2].\n   */\n  protected conv2dTransposeShaderLike(\n      x: Array3D, origWeights: Array4D, origStride: number,\n      origPad: number): Array3D {\n    const fSize = origWeights.shape[0];\n    const pad = fSize - 1 - origPad;\n    const origInputDepth = origWeights.shape[2];\n    const origOutputDepth = origWeights.shape[3];\n    const [xRows, xCols, xDepth] = x.shape;\n\n    // Dilate the input.\n    const xRowsDilated = (xRows - 1) * origStride + 1;\n    const xColsDilated = (xCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1,\n        pad);\n    const y = Array3D.zeros(outputShape);\n\n    for (let d2 = 0; d2 < origInputDepth; ++d2) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          // Shader code begins.\n          const xRCorner = yR - pad;\n          const xCCorner = yC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const xR = (xRCorner + wR) / origStride;\n            if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const xC = (xCCorner + wC) / origStride;\n              if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) {\n                continue;\n              }\n              for (let d1 = 0; d1 < origOutputDepth; ++d1) {\n                const pixel = x.get(xR, xC, d1);\n                const weight =\n                    origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1);\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          y.set(dotProd, yR, yC, d2);\n        }\n      }\n    }\n    return y;\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    const dW = Array4D.zeros(weightsShape);\n\n    const yNumRows = dY.shape[0];\n    const yNumCols = dY.shape[1];\n    const xNumRows = x.shape[0];\n    const xNumCols = x.shape[1];\n\n    for (let wR = 0; wR < fSize; ++wR) {\n      const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride));\n      const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride);\n\n      for (let wC = 0; wC < fSize; ++wC) {\n        const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride));\n        const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride);\n\n        for (let d1 = 0; d1 < inputDepth; ++d1) {\n          for (let d2 = 0; d2 < outputDepth; ++d2) {\n            // Need to convolve.\n            let dotProd = 0;\n            for (let yR = yRMin; yR < yRMax; ++yR) {\n              const xR = wR + yR * stride - zeroPad;\n              for (let yC = yCMin; yC < yCMax; ++yC) {\n                const xC = wC + yC * stride - zeroPad;\n                dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2);\n              }\n            }\n            dW.set(dotProd, wR, wC, d1, d2);\n          }\n        }\n      }\n    }\n    return dW;\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const numRows = dY.shape[0];\n    const numCols = dY.shape[1];\n    const values = new Float32Array(outputDepth);\n    for (let d2 = 0; d2 < outputDepth; ++d2) {\n      let sum = 0;\n      for (let r = 0; r < numRows; ++r) {\n        for (let c = 0; c < numCols; ++c) {\n          sum += dY.get(r, c, d2);\n        }\n      }\n      values[d2] = sum;\n    }\n    return Array1D.new(values);\n  }\n\n  protected switchDimInternal<T extends NDArray>(t: T, newDim: number[]): T {\n    const newShape: number[] = new Array(t.rank);\n    for (let i = 0; i < newShape.length; i++) {\n      newShape[i] = t.shape[newDim[i]];\n    }\n    const resultValues = new Float32Array(t.size);\n    const values = t.getValues();\n    const result = NDArray.make<T>(newShape, {values: resultValues});\n    for (let i = 0; i < t.size; ++i) {\n      const loc = t.indexToLoc(i);\n\n      // Permute location.\n      const newLoc: number[] = new Array(loc.length);\n      for (let i = 0; i < newLoc.length; i++) {\n        newLoc[i] = loc[newDim[i]];\n      }\n\n      const newIndex = result.locToIndex(newLoc);\n      resultValues[newIndex] = values[i];\n    }\n    return result;\n  }\n\n  private pool(\n      x: Array3D, fSize: number, stride: number, pad: number,\n      poolType: 'max'|'min'|'avg') {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape = conv_util.computeOutputShape3D(\n        [xRows, xCols, depth], fSize, depth, stride, pad);\n    const y = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < y.shape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < y.shape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n\n\n          let minMaxValue =\n              (poolType === 'max' ? Number.NEGATIVE_INFINITY :\n                                    Number.POSITIVE_INFINITY);\n          let avgValue = 0;\n\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (isNaN(pixel)) {\n                minMaxValue = NaN;\n                avgValue = NaN;\n                break;\n              }\n              if ((poolType === 'max' && pixel > minMaxValue) ||\n                  (poolType === 'min' && pixel < minMaxValue)) {\n                minMaxValue = pixel;\n              } else if (poolType === 'avg') {\n                avgValue += pixel / (fSize * fSize);\n              }\n            }\n            if (isNaN(minMaxValue)) {\n              break;\n            }\n          }\n          y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d);\n        }\n      }\n    }\n    return y;\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'max');\n  }\n\n  maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) {\n    const [xRows, xCols, depth] = x.shape;\n    const outputShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad);\n    const maxPositions = Array3D.zeros(outputShape);\n    for (let d = 0; d < depth; ++d) {\n      for (let yR = 0; yR < outputShape[0]; ++yR) {\n        const xRCorner = yR * stride - pad;\n        const xRMin = Math.max(0, xRCorner);\n        const xRMax = Math.min(xRows, fSize + xRCorner);\n        for (let yC = 0; yC < outputShape[1]; ++yC) {\n          const xCCorner = yC * stride - pad;\n          const xCMin = Math.max(0, xCCorner);\n          const xCMax = Math.min(xCols, fSize + xCCorner);\n          let maxValue = Number.NEGATIVE_INFINITY;\n          let maxPosition = -1;\n          for (let xR = xRMin; xR < xRMax; ++xR) {\n            const wR = xR - xRCorner;\n            for (let xC = xCMin; xC < xCMax; ++xC) {\n              const wC = xC - xCCorner;\n              const pixel = x.get(xR, xC, d);\n              if (pixel > maxValue) {\n                maxValue = pixel;\n                maxPosition = wR * fSize + wC;\n              }\n            }\n          }\n          maxPositions.set(maxPosition, yR, yC, d);\n        }\n      }\n    }\n    return maxPositions;\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad);\n    const pad = fSize - 1 - origPad;\n    const [dyRows, dyCols, depth] = dy.shape;\n\n    // Dilate the input.\n    const dyRowsDilated = (dyRows - 1) * origStride + 1;\n    const dxColsDilated = (dyCols - 1) * origStride + 1;\n\n    const outputShape = conv_util.computeOutputShape3D(\n        [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad);\n    const dx = Array3D.zeros(outputShape);\n\n    for (let d = 0; d < depth; ++d) {\n      for (let dxR = 0; dxR < dx.shape[0]; ++dxR) {\n        for (let dxC = 0; dxC < dx.shape[1]; ++dxC) {\n          // Shader code begins.\n          const dyRCorner = dxR - pad;\n          const dyCCorner = dxC - pad;\n          let dotProd = 0;\n          for (let wR = 0; wR < fSize; ++wR) {\n            const dyR = (dyRCorner + wR) / origStride;\n            if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) {\n              continue;\n            }\n            for (let wC = 0; wC < fSize; ++wC) {\n              const dyC = (dyCCorner + wC) / origStride;\n              if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) {\n                continue;\n              }\n              const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d);\n              const curPos = wR * fSize + wC;\n\n              const mask = maxPos === curPos ? 1 : 0;\n              if (mask === 0) {\n                continue;\n              }\n\n              const pixel = dy.get(dyR, dyC, d);\n              dotProd += pixel * mask;\n            }\n          }\n          dx.set(dotProd, dxR, dxC, d);\n        }\n      }\n    }\n    return dx;\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'min');\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    return this.pool(x, fSize, stride, pad, 'avg');\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]);\n\n    const effectiveInputSize =\n        alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape;\n    const effectiveOutputSize = alignCorners ?\n        [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] :\n        output.shape;\n    for (let r = 0; r < output.shape[0]; r++) {\n      for (let c = 0; c < output.shape[1]; c++) {\n        for (let d = 0; d < output.shape[2]; d++) {\n          // Begin shader.\n\n          // Compute the fractional index of the source.\n          const sourceFracRow =\n              (effectiveInputSize[0]) * r / (effectiveOutputSize[0]);\n          const sourceFracCol =\n              (effectiveInputSize[1]) * c / (effectiveOutputSize[1]);\n\n          const sourceRowFloor = Math.floor(sourceFracRow);\n          const sourceRowCeil =\n              Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow));\n          const sourceColFloor = Math.floor(sourceFracCol);\n          const sourceColCeil =\n              Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol));\n\n          const topLeft = x.get(sourceRowFloor, sourceColFloor, d);\n          const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d);\n          const topRight = x.get(sourceRowFloor, sourceColCeil, d);\n          const bottomRight = x.get(sourceRowCeil, sourceColCeil, d);\n\n          const rowFrac = sourceFracRow - sourceRowFloor;\n          const colFrac = sourceFracCol - sourceColFloor;\n\n          const top = topLeft + (topRight - topLeft) * colFrac;\n          const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;\n          const newValue = top + (bottom - top) * rowFrac;\n\n          output.set(newValue, r, c, d);\n        }\n      }\n    }\n\n    return output;\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon = .001, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xValues = x.getValues();\n    const meanValues = mean.getValues();\n    const varianceValues = variance.getValues();\n    const scaleValues = scale ? scale.getValues() : new Float32Array([1]);\n    const offsetValues = offset ? offset.getValues() : new Float32Array([0]);\n    const outValues = new Float32Array(xValues.length);\n\n    for (let i = 0; i < xValues.length; i++) {\n      outValues[i] = offsetValues[i % offsetValues.length] +\n          (xValues[i] - meanValues[i % meanValues.length]) *\n              scaleValues[i % scaleValues.length] /\n              Math.sqrt(\n                  varianceValues[i % varianceValues.length] + varianceEpsilon);\n    }\n    return NDArray.make<Array3D>(x.shape, {values: outValues});\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport * as concat3d_util from './concat3d_util';\nimport * as conv_util from './conv_util';\nimport {MatrixOrientation, NDArrayMath} from './math';\nimport * as ndarray from './ndarray';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray';\nimport * as addscaledmat_gpu from './webgl/addscaledmat_gpu';\nimport * as addsubmuldiv_gpu from './webgl/addsubmuldiv_gpu';\nimport {OperandType} from './webgl/addsubmuldiv_gpu';\nimport * as argmaxequals_gpu from './webgl/argmaxequals_gpu';\nimport * as argminmax_gpu from './webgl/argminmax_gpu';\nimport * as avg_pool_gpu from './webgl/avg_pool_gpu';\nimport * as batchnorm_gpu from './webgl/batchnorm_gpu';\nimport * as concat3d_gpu from './webgl/concat3d_gpu';\nimport * as conv_backprop_gpu from './webgl/conv_backprop_gpu';\nimport * as conv_gpu from './webgl/conv_gpu';\nimport * as copy_gpu from './webgl/copy_gpu';\nimport * as exp_gpu from './webgl/exp_gpu';\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport * as gpgpu_util from './webgl/gpgpu_util';\nimport * as log_gpu from './webgl/log_gpu';\nimport * as logsumexp_gpu from './webgl/logsumexp_gpu';\nimport * as max_pool_backprop_gpu from './webgl/max_pool_backprop_gpu';\nimport * as max_pool_gpu from './webgl/max_pool_gpu';\nimport * as min_pool_gpu from './webgl/min_pool_gpu';\nimport * as minmax_gpu from './webgl/minmax_gpu';\nimport * as mulmat_gpu from './webgl/mulmat_gpu';\nimport * as neg_gpu from './webgl/neg_gpu';\nimport * as pool_gpu from './webgl/pool_gpu';\nimport * as reducesum_gpu from './webgl/reducesum_gpu';\nimport * as relu_gpu from './webgl/relu_gpu';\nimport * as reshape_gpu from './webgl/reshape_gpu';\nimport * as resize_bilinear_gpu from './webgl/resize_bilinear_gpu';\nimport * as shader_compiler from './webgl/shader_compiler';\nimport * as sigmoid_gpu from './webgl/sigmoid_gpu';\nimport * as step_gpu from './webgl/step_gpu';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as trig_gpu from './webgl/trig_gpu';\nimport * as webgl_util from './webgl/webgl_util';\n\nconst ARGMAX_PROG = 'argmax';\nconst ARGMAX_EQUALS_PROG = 'argmaxequals';\nconst ARGMIN_PROG = 'argmin';\n\nconst BATCHNORM_PROG = 'batchnorm';\n\nconst COPY_PROG = 'copy';\nconst CONCAT_PROG = 'concat';\n\n// Matrix algebra.\nconst ADD_SCALED_MAT_PROG = 'addscaledmat';\nconst MATMUL_PROG = 'matmul';\n\n// Element-wise ops.\nconst RELU_PROG = 'relu';\nconst TANH_PROG = 'tanh';\nconst SIN_PROG = 'sin';\nconst SIGMOID_PROG = 'sigmoid';\nconst MAX_PROG = 'max';\nconst MIN_PROG = 'min';\nconst NEG_PROG = 'neg';\nconst EXP_PROG = 'exp';\nconst LOG_PROG = 'log';\nconst SUM_PROG = 'sum';\nconst STEP_PROG = 'step';\nconst LOGSUMEXP_PROG = 'logsumexp';\nconst RESHAPE_PROG = 'reshape';\nconst ADD_SUM_MUL_DIV_PROG = 'addsummuldiv';\n\n// Convolution.\nconst CONV2D_PROG = 'conv';\nconst CONV2D_TRANSPOSE_PROG = 'conv_transpose';\nconst CONV2D_DERW_PROG = 'conv_derw';\nconst CONV2D_DERB_PROG = 'conv_derb';\nconst MAX_POOL_PROG = 'maxpool';\nconst MAX_POOL_POSITIONS_PROG = 'maxpool_posn';\nconst MAX_POOL_BACKPROP_PROG = 'maxpool_backprop';\nconst MIN_POOL_PROG = 'minpool';\nconst AVG_POOL_PROG = 'avgpool';\n\nconst RESIZE_BILINEAR_PROG = 'resizebilin';\n\nfunction makeCopyProgramName(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  const shapeName = `${sourceShapeRowCol[0]}_${sourceShapeRowCol[1]}`;\n  const srcSizeName = `${sourceSizeRowCol[0]}_${sourceSizeRowCol[1]}`;\n  const dstSizeName = `${destSizeRowCol[0]}_${destSizeRowCol[1]}`;\n  return `${COPY_PROG}_${shapeName}_${srcSizeName}_${dstSizeName}`;\n}\n\nexport class NDArrayMathGPU extends NDArrayMath {\n  private gpgpu: GPGPUContext;\n  private textureManager: TextureManager;\n  private programCache: {[key: string]: WebGLProgram} = {};\n  private gpgpuCreatedLocally: boolean;\n\n  constructor(gpgpu?: GPGPUContext, safeMode = true) {\n    super(safeMode);\n    if (gpgpu == null) {\n      const gl = gpgpu_util.createWebGLContext();\n      this.gpgpu = new GPGPUContext(gl);\n      this.gpgpuCreatedLocally = true;\n    } else {\n      this.gpgpu = gpgpu;\n      this.gpgpuCreatedLocally = false;\n    }\n\n    this.textureManager = new TextureManager(this.gpgpu);\n\n    ndarray.initializeGPU(this.gpgpu, this.textureManager);\n  }\n\n  getGPGPUContext(): GPGPUContext {\n    return this.gpgpu;\n  }\n\n  protected cloneInternal<T extends NDArray>(ndarray: T): T {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC),\n        () => copy_gpu.getFragmentShaderSource(\n            textureShapeRC, textureShapeRC, textureShapeRC));\n\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    copy_gpu.copy(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0],\n        textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reshapeInternal<T1 extends NDArray, T2 extends NDArray>(\n      ndarray: T1, newShape: number[]): T2 {\n    let newTexShape: [number, number];\n\n    switch (newShape.length) {\n      case 0:\n        newTexShape = [1, 1];\n        break;\n      case 1:\n        newTexShape = [newShape[0], 1];\n        break;\n      case 2:\n        newTexShape = [newShape[0], newShape[1]];\n        break;\n      case 3:\n        newTexShape = [newShape[0], newShape[1] * newShape[2]];\n        break;\n      default:\n        throw Error(\n            `Reshapes into ${newShape.length}-dim ndarray is not yet ` +\n            `supported on GPU`);\n    }\n\n    const actualTexShape = ndarray.getTextureShapeRC(newTexShape);\n    let clonedArray: T1;\n    if (!util.arraysEqual(actualTexShape, newTexShape)) {\n      clonedArray = this.reshapeTexture(ndarray, newTexShape);\n    } else {\n      clonedArray = this.cloneInternal(ndarray);\n    }\n    return clonedArray.reshape<T2>(newShape);\n  }\n\n  protected slice2DInternal(\n      input: Array2D, beginRowCol: [number, number],\n      sizeRowCol: [number, number]): Array2D {\n    const result = NDArray.make<Array2D>(sizeRowCol, {\n      texture: this.textureManager.acquireTexture(sizeRowCol),\n      textureShapeRC: sizeRowCol\n    });\n    this.copy2DInternal(\n        input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol);\n    return result;\n  }\n\n  protected copy2DInternal(\n      source: Array2D, sourceBeginRowCol: [number, number],\n      sourceSizeRowCol: [number, number], dest: Array2D,\n      destBeginRowCol: [number, number],\n      destSizeRowCol: [number, number]): void {\n    const sourceShapeRC = source.getTextureShapeRC();\n    const destShapeRC = dest.getTextureShapeRC();\n    const program = this.getAndSaveProgram(\n        makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol),\n        () => copy_gpu.getFragmentShaderSource(\n            sourceShapeRC, sourceSizeRowCol, destSizeRowCol));\n\n    copy_gpu.copy(\n        this.gpgpu, program, source.getTexture(), sourceShapeRC,\n        sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC,\n        destBeginRowCol, destSizeRowCol);\n  }\n\n  protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D {\n    const x1TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x1.shape);\n    const x2TexShapeRC: [number, number] =\n        conv_util.computeTexShapeFrom3D(x2.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC);\n    let cleanupX1 = false;\n    if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) {\n      x1 = this.reshapeTexture(x1, x1TexShapeRC);\n      cleanupX1 = true;\n    }\n    const actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC);\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) {\n      x2 = this.reshapeTexture(x2, x2TexShapeRC);\n      cleanupX2 = true;\n    }\n\n    const resultShapeRCD =\n        concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis);\n\n    const program = this.getAndSaveProgram(\n        `${CONCAT_PROG}_${x1.shape}_${x2.shape}_${axis}`,\n        () => concat3d_gpu.getFragmentShaderSource(\n            x1.shape, x2.shape, resultShapeRCD, axis));\n\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    concat3d_gpu.concat3D(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX1) {\n      x1.dispose();\n    }\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected scalarPlusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '+', OperandType.MATRIX) as T;\n  }\n\n  protected arrayMinusScalarInternal<T extends NDArray>(a: T, c: Scalar): T {\n    return this.addSubMulDiv(\n        a, c, a.shape, OperandType.MATRIX, '-', OperandType.SCALAR) as T;\n  }\n\n  protected scalarMinusArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '-', OperandType.MATRIX) as T;\n  }\n\n  protected scaledArrayAddInternal<T extends NDArray>(\n      c1: Scalar, a: T, c2: Scalar, b: T) {\n    let cleanupB = false;\n    if (!this.doGPUShapesMatch(a, b)) {\n      b = this.reshapeTexture(b, a.getTextureShapeRC());\n      cleanupB = true;\n    }\n\n    const program = this.getAndSaveProgram(\n        ADD_SCALED_MAT_PROG, () => addscaledmat_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    addscaledmat_gpu.addScaledMatrices(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n    // Bring the result back to the original shape.\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected scalarTimesArrayInternal<T extends NDArray>(c: Scalar, a: T): T {\n    return this.addSubMulDiv(\n        c, a, a.shape, OperandType.SCALAR, '*', OperandType.MATRIX) as T;\n  }\n\n  protected negInternal<T extends NDArray>(a: T): T {\n    const program = this.getAndSaveProgram(\n        NEG_PROG, () => neg_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = a.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    neg_gpu.neg(\n        this.gpgpu, program, a.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(a.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  private reshapeTexture<T extends NDArray>(a: T, newTextureShape: [\n    number, number\n  ]): T {\n    const aTexShape = a.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        RESHAPE_PROG, () => reshape_gpu.getFragmentShaderSource());\n\n    const resultTexture = this.textureManager.acquireTexture(newTextureShape);\n    reshape_gpu.reshape(\n        this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1],\n        resultTexture, newTextureShape[0], newTextureShape[1]);\n\n    return NDArray.make<T>(\n        a.shape, {texture: resultTexture, textureShapeRC: newTextureShape});\n  }\n\n  protected matMulInternal(\n      a: Array2D, b: Array2D, aOrientation: MatrixOrientation,\n      bOrientation: MatrixOrientation): Array2D {\n    const sharedDim =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0];\n    const outerShapeA =\n        (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1];\n    const outerShapeB =\n        (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0];\n    const outShape: [number, number] = [outerShapeA, outerShapeB];\n    const outTexShape =\n        webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape);\n    const outTexture = this.textureManager.acquireTexture(outTexShape);\n    const out = new Array2D(\n        outShape, {texture: outTexture, textureShapeRC: outTexShape});\n\n    const key = shader_compiler.makeShaderKey([a, b], out);\n    const program = this.getAndSaveProgram(\n        `${MATMUL_PROG}_${key}_${aOrientation}_${bOrientation}`,\n        () => mulmat_gpu.getFragmentShader(\n            a, b, out, aOrientation, bOrientation));\n\n    mulmat_gpu.multiplyMatrix(\n        this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture,\n        outTexShape);\n\n    return out;\n  }\n\n  protected elementWiseMulInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '*', OperandType.MATRIX) as T;\n  }\n\n  protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected batchNormalization3DInternal(\n      x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D,\n      varianceEpsilon: number, scale?: Array3D|Array1D,\n      offset?: Array3D|Array1D): Array3D {\n    const xTexShape = x.getTextureShapeRC();\n\n    let cleanupMean = false;\n    const preferredMeanTexShape: [number, number] =\n        mean.rank === 1 ? [1, mean.size] : xTexShape;\n    let meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) {\n      mean = this.reshapeTexture(mean, preferredMeanTexShape);\n      meanTexShape = preferredMeanTexShape;\n      cleanupMean = true;\n    }\n\n    let cleanupVariance = false;\n    const preferredVarianceTexShape: [number, number] =\n        variance.rank === 1 ? [1, variance.size] : xTexShape;\n    let varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape);\n    if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) {\n      variance = this.reshapeTexture(variance, preferredVarianceTexShape);\n      varianceTexShape = preferredVarianceTexShape;\n      cleanupVariance = true;\n    }\n\n    let scaleTexShape: [number, number]|null = null;\n    let cleanupScale = false;\n    if (scale != null) {\n      const preferredScaleTexShape: [number, number] =\n          scale.rank === 1 ? [1, scale.size] : xTexShape;\n\n      scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape);\n      if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) {\n        scale = this.reshapeTexture(scale, preferredScaleTexShape);\n        scaleTexShape = preferredScaleTexShape;\n        cleanupScale = true;\n      }\n    }\n\n    let offsetTexShape: [number, number]|null = null;\n    let cleanupOffset = false;\n    if (offset != null) {\n      const preferredOffsetTexShape: [number, number] =\n          offset.rank === 1 ? [1, offset.size] : xTexShape;\n\n      offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape);\n      if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) {\n        offset = this.reshapeTexture(offset, preferredOffsetTexShape);\n        offsetTexShape = preferredOffsetTexShape;\n        cleanupOffset = true;\n      }\n    }\n\n    const resultTexShape: [number, number] = x.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${BATCHNORM_PROG}_${xTexShape}_${meanTexShape}_${varianceTexShape}_` +\n            `${scaleTexShape!}_${offsetTexShape!}_${varianceEpsilon}`,\n        () => batchnorm_gpu.getFragmentShaderSource(\n            xTexShape, meanTexShape, varianceTexShape, offsetTexShape,\n            scaleTexShape, varianceEpsilon));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    batchnorm_gpu.batchNormalization(\n        this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(),\n        meanTexShape, variance.getTexture(), varianceTexShape,\n        offset != null ? offset.getTexture() : null,\n        offset != null ? offsetTexShape : null,\n        scale != null ? scale.getTexture() : null,\n        scale != null ? scaleTexShape : null, resultTexture, resultTexShape);\n\n    if (cleanupMean) {\n      mean.dispose();\n    }\n    if (cleanupVariance) {\n      variance.dispose();\n    }\n    if (cleanupScale) {\n      scale!.dispose();\n    }\n    if (cleanupOffset) {\n      offset!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        x.shape, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  protected switchDimInternal<T extends NDArray>(a: T, newDim: number[]): T {\n    throw new Error('Not yet implemented!');\n  }\n\n  protected sumInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${SUM_PROG}_${numRows}_${numColumns}`,\n        () => reducesum_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMinInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMIN_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_PROG}_${numRows}_${numColumns}`,\n        () => argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argminmax_gpu.argMinMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar {\n    // If the texture shapes doesn't match, do a physical reshape so they do.\n    const actualX1TexShape = x1.getTextureShapeRC();\n    const actualX2TexShape = x2.getTextureShapeRC();\n    let cleanupX2 = false;\n    if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) {\n      x2 = this.reshapeTexture(x2, actualX1TexShape);\n      cleanupX2 = true;\n    }\n\n    const textureShapeRC = x1.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${ARGMAX_EQUALS_PROG}_${numRows}_${numColumns}`,\n        () => argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(\n            numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    argmaxequals_gpu.argMaxEquals(\n        this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows,\n        numColumns, resultTexture);\n\n    if (cleanupX2) {\n      x2.dispose();\n    }\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected topKInternal(ndarray: NDArray, k: number):\n      {values: Array1D, indices: Array1D} {\n    throw new Error('topK GPU not yet implemented!');\n  }\n\n  protected minInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MIN_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMinFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected maxInternal(ndarray: NDArray): Scalar {\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const [numRows, numColumns] = textureShapeRC;\n\n    const program = this.getAndSaveProgram(\n        `${MAX_PROG}_${numRows}_${numColumns}`,\n        () => minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns));\n\n    const resultTexture = this.textureManager.acquireTexture([1, 1]);\n\n    minmax_gpu.minMax(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        resultTexture);\n\n    return new Scalar({texture: resultTexture});\n  }\n\n  protected divideInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '/', OperandType.MATRIX) as T;\n  }\n\n  protected scalarDividedByArrayInternal<T extends NDArray>(c: Scalar, a: T):\n      T {\n    return this.addSubMulDiv(\n               c, a, a.shape, OperandType.SCALAR, '/', OperandType.MATRIX) as T;\n  }\n\n  protected arrayDividedByScalarInternal<T extends NDArray>(a: T, c: Scalar):\n      T {\n    return this.addSubMulDiv(\n               a, c, a.shape, OperandType.MATRIX, '/', OperandType.SCALAR) as T;\n  }\n\n  protected addInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '+', OperandType.MATRIX) as T;\n  }\n\n  protected subInternal<T extends NDArray>(a: T, b: T): T {\n    return this.addSubMulDiv(\n        a, b, a.shape, OperandType.MATRIX, '-', OperandType.MATRIX) as T;\n  }\n\n  protected logSumExpInternal(ndarray: NDArray): Scalar {\n    const [numRows, numColumns] = ndarray.getTextureShapeRC();\n\n    const program = this.getAndSaveProgram(\n        `${LOGSUMEXP_PROG}_${numRows}_${numColumns}`,\n        () => logsumexp_gpu.getFragmentShaderSource(numRows, numColumns));\n\n    const result =\n        new Scalar({texture: this.textureManager.acquireTexture([1, 1])});\n\n    reducesum_gpu.reduceSum(\n        this.gpgpu, program, ndarray.getTexture(), numRows, numColumns,\n        result.getTexture());\n\n    return result;\n  }\n\n  protected expInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        EXP_PROG, () => exp_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    exp_gpu.exp(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected logInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        LOG_PROG, () => log_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n    log_gpu.log(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected reluInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        RELU_PROG, () => relu_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    relu_gpu.relu(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sigmoidInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIGMOID_PROG, () => sigmoid_gpu.getSigmoidFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    sigmoid_gpu.sigmoid(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected tanhInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        TANH_PROG, () => trig_gpu.getTanhFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.tanh(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected sinInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        SIN_PROG, () => trig_gpu.getSinFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    trig_gpu.sin(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected stepInternal<T extends NDArray>(ndarray: T): T {\n    const program = this.getAndSaveProgram(\n        STEP_PROG, () => step_gpu.getFragmentShaderSource());\n\n    const textureShapeRC = ndarray.getTextureShapeRC();\n    const resultTexture = this.textureManager.acquireTexture(textureShapeRC);\n\n    step_gpu.step(\n        this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0],\n        textureShapeRC[1], resultTexture);\n\n    return NDArray.make<T>(\n        ndarray.shape, {texture: resultTexture, textureShapeRC});\n  }\n\n  protected conv2dInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, stride: number,\n      zeroPad: number): Array3D {\n    const fieldSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const progKey = [\n      CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_gpu.getFragmentShaderSource(\n          x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(outputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    const resultShape = conv_util.computeOutputShape3D(\n        x.shape, fieldSize, outputDepth, stride, zeroPad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_gpu.convolve(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB && biases != null) {\n      biases.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected conv2dBackPropInternal(\n      x: Array3D, dy: Array3D, weights: Array4D, stride: number,\n      pad: number): {dx: Array3D, dw: Array4D, db: Array1D} {\n    const fSize = weights.shape[0];\n    const inputDepth = weights.shape[2];\n    const outputDepth = weights.shape[3];\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const yTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupX = false;\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dy.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dy = this.reshapeTexture(dy, yTexShape);\n      cleanupY = true;\n    }\n\n    const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad);\n    const db = this.conv2dDerBias(dy);\n    const dx = this.conv2dTransposeInternal(\n        dy, weights, null /** biases */, stride, pad);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupY) {\n      dy.dispose();\n    }\n    return {dx, db, dw};\n  }\n\n  protected conv2dTransposeInternal(\n      x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number,\n      origPad: number): Array3D {\n    const origInputDepth = weights.shape[2];\n    const origOutputDepth = weights.shape[3];\n    const fieldSize = weights.shape[0];\n\n    const progKey = [\n      CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride,\n      origPad, biases != null\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderConvTransposeSource(\n          x.shape, fieldSize, origInputDepth, origStride, origPad,\n          biases != null);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const wTexShape = conv_util.computeWeightsTexShape(\n        origInputDepth, origOutputDepth, fieldSize);\n    const biasTexShape = conv_util.computeBiasesTexShape(origInputDepth);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupW = false;\n    const actualWTexShape = weights.getTextureShapeRC(wTexShape);\n    if (!util.arraysEqual(actualWTexShape, wTexShape)) {\n      weights = this.reshapeTexture(weights, wTexShape);\n      cleanupW = true;\n    }\n\n    let cleanupB = false;\n    if (biases != null) {\n      const actualBiasTexShape = biases.getTextureShapeRC(biasTexShape);\n      if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) {\n        biases = this.reshapeTexture(biases, biasTexShape);\n        cleanupB = true;\n      }\n    }\n\n    // Figure out the output shape by dilating the input.\n    const dilatedRC =\n        conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride);\n    const pad = fieldSize - 1 - origPad;\n    const resultShape = conv_util.computeOutputShape3D(\n        [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize,\n        origInputDepth, 1, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.convTranspose(\n        this.gpgpu, program, x.getTexture(), weights.getTexture(),\n        biases != null ? biases.getTexture() : null, resultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupW) {\n      weights.dispose();\n    }\n    if (cleanupB) {\n      biases!.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerWeights(\n      x: Array3D, dY: Array3D, fSize: number, stride: number,\n      zeroPad: number): Array4D {\n    const inputDepth = x.shape[2];\n    const outputDepth = dY.shape[2];\n    const progKey = [\n      CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad\n    ].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerWeightsSource(\n          x.shape, fSize, outputDepth, stride, zeroPad);\n    });\n\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const yShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, outputDepth, stride, zeroPad);\n    const yTexShape = conv_util.computeTexShapeFrom3D(yShape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape =\n        conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derWeights(\n        this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex,\n        resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    const weightsShape =\n        conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize);\n    return NDArray.make<Array4D>(\n        weightsShape, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  conv2dDerBias(dY: Array3D): Array1D {\n    const outputDepth = dY.shape[2];\n    const progKey = [CONV2D_DERB_PROG, dY.shape].join('_');\n    const program = this.getAndSaveProgram(progKey, () => {\n      return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape);\n    });\n    const yTexShape = conv_util.computeTexShapeFrom3D(dY.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    let cleanupY = false;\n    const actualYTexShape = dY.getTextureShapeRC(yTexShape);\n    if (!util.arraysEqual(actualYTexShape, yTexShape)) {\n      dY = this.reshapeTexture(dY, yTexShape);\n      cleanupY = true;\n    }\n\n    const resultTexShape = conv_util.computeBiasesTexShape(outputDepth);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    conv_backprop_gpu.derBias(\n        this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape);\n\n    if (cleanupY) {\n      dY.dispose();\n    }\n\n    return NDArray.make<Array1D>(\n        [outputDepth], {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  private pool(\n      program: WebGLProgram, x: Array3D, fSize: number, stride: number,\n      pad: number): Array3D {\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    const resultShape =\n        conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape);\n    const poolResultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    pool_gpu.poolCommon(\n        this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape);\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    return NDArray.make<Array3D>(\n        resultShape, {texture: poolResultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected maxPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const maxPoolProgKey =\n        [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, () => {\n      return max_pool_gpu.getFragmentShaderMaxPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(maxPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected minPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const minPoolProgKey =\n        [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const minPoolProgram = this.getAndSaveProgram(minPoolProgKey, () => {\n      return min_pool_gpu.getFragmentShaderMinPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(minPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected avgPoolInternal(\n      x: Array3D, fSize: number, stride: number, pad: number): Array3D {\n    const avgPoolProgKey =\n        [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_');\n    const avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, () => {\n      return avg_pool_gpu.getFragmentShaderAvgPoolSource(\n          x.shape, fSize, stride, pad);\n    });\n\n    return this.pool(avgPoolProgram, x, fSize, stride, pad);\n  }\n\n  protected maxPoolBackpropInternal(\n      dy: Array3D, x: Array3D, fSize: number, origStride: number,\n      origPad: number): Array3D {\n    const maxPoolPositionsProgKey = [\n      MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad\n    ].join('_');\n    const maxPoolPositionsProgram =\n        this.getAndSaveProgram(maxPoolPositionsProgKey, () => {\n          return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(\n              x.shape, fSize, origStride, origPad);\n        });\n\n    const maxPoolResultShape = conv_util.computeOutputShape3D(\n        x.shape, fSize, x.shape[2], origStride, origPad);\n    const maxPoolResultTexShape =\n        conv_util.computeTexShapeFrom3D(maxPoolResultShape);\n    const maxPoolPositionsResultTex =\n        this.textureManager.acquireTexture(maxPoolResultTexShape);\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const xTexShape = conv_util.computeTexShapeFrom3D(x.shape);\n    const actualXTexShape = x.getTextureShapeRC(xTexShape);\n    let cleanupX = false;\n    if (!util.arraysEqual(actualXTexShape, xTexShape)) {\n      x = this.reshapeTexture(x, xTexShape);\n      cleanupX = true;\n    }\n\n    max_pool_gpu.maxPoolCommon(\n        this.gpgpu, maxPoolPositionsProgram, x.getTexture(),\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    const maxPoolBackpropProgKey = [\n      MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad\n    ].join('_');\n    const program = this.getAndSaveProgram(maxPoolBackpropProgKey, () => {\n      return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(\n          dy.shape, fSize, origStride, origPad);\n    });\n\n    const dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape);\n\n    // If the texture shapes doesn't match the shapes that shaders expect,\n    // do physical texture reshapes on the GPU.\n    const actualDyTexShape = dy.getTextureShapeRC(dyTexShape);\n    let cleanupDy = false;\n    if (!util.arraysEqual(actualDyTexShape, dyTexShape)) {\n      dy = this.reshapeTexture(dy, dyTexShape);\n      cleanupDy = true;\n    }\n\n    const dilatedDyRC =\n        conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride);\n    const pad = fSize - 1 - origPad;\n    const resultShapeRCD = conv_util.computeOutputShape3D(\n        [dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1,\n        pad);\n    const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD);\n    const resultTex = this.textureManager.acquireTexture(resultTexShape);\n\n    max_pool_backprop_gpu.maxPoolBackprop(\n        this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex,\n        resultTex, resultTexShape);\n\n    if (cleanupDy) {\n      dy.dispose();\n    }\n\n    if (cleanupX) {\n      x.dispose();\n    }\n\n    this.textureManager.releaseTexture(\n        maxPoolPositionsResultTex, maxPoolResultTexShape);\n\n    return NDArray.make<Array3D>(\n        resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape});\n  }\n\n  protected resizeBilinear3DInternal(\n      x: Array3D, newShape2D: [number, number],\n      alignCorners: boolean): Array3D {\n    const programKey =\n        [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_');\n\n    const newShapeRCD: [number, number, number] =\n        [newShape2D[0], newShape2D[1], x.shape[2]];\n    const resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD);\n\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => resize_bilinear_gpu.getFragmentShaderSource(\n            x.shape, newShape2D, alignCorners));\n\n    const resultTexture = this.textureManager.acquireTexture(resultTexShape);\n\n    resize_bilinear_gpu.resizeBilinear(\n        this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape);\n\n    return NDArray.make<Array3D>(\n        newShapeRCD, {texture: resultTexture, textureShapeRC: resultTexShape});\n  }\n\n  private getAndSaveProgram(programKey: string, getShaderSource: () => string):\n      WebGLProgram {\n    if (!(programKey in this.programCache)) {\n      this.programCache[programKey] =\n          this.gpgpu.createProgram(getShaderSource());\n    }\n    return this.programCache[programKey];\n  }\n\n  private addSubMulDiv(\n      a: NDArray, b: NDArray, resultShape: number[],\n      operandA: addsubmuldiv_gpu.OperandType,\n      opType: addsubmuldiv_gpu.Operation,\n      operandB: addsubmuldiv_gpu.OperandType): NDArray {\n    let cleanupB = false;\n\n    const aOrientation = MatrixOrientation.REGULAR;\n    let bOrientation = MatrixOrientation.REGULAR;\n\n    let logicalBTexShape: [number, number];\n\n    if (operandA === OperandType.MATRIX && operandB === OperandType.MATRIX) {\n      util.assertShapesMatch(a.shape, b.shape);\n\n      if (a.inGPU()) {\n        // Prefer B to have the shape of A.\n        b.getTextureShapeRC(a.getTextureShapeRC());\n      } else if (b.inGPU()) {\n        // Prefer A to have the shape of B.\n        a.getTextureShapeRC(b.getTextureShapeRC());\n      }\n\n      const aTexShape = a.getTextureShapeRC();\n      const bTexShape = b.getTextureShapeRC();\n      logicalBTexShape = bTexShape;\n\n      if (a.rank === 1) {\n        // When dealing with vectors, we can sample in transposed way without\n        // the need to do physical reshape.\n        if (!util.arraysEqual(bTexShape, aTexShape)) {\n          bOrientation = MatrixOrientation.TRANSPOSED;\n          logicalBTexShape = [bTexShape[1], bTexShape[0]];\n        }\n      }\n\n      if (!util.arraysEqual(aTexShape, logicalBTexShape)) {\n        b = this.reshapeTexture(b, aTexShape);\n        bOrientation = MatrixOrientation.REGULAR;\n        logicalBTexShape = b.getTextureShapeRC();\n        cleanupB = true;\n      }\n    } else {\n      logicalBTexShape = b.getTextureShapeRC();\n    }\n\n    const aTexShape = a.getTextureShapeRC();\n    const bTexShape = b.getTextureShapeRC();\n\n    const programKey = [\n      ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB,\n      bOrientation\n    ].join('_');\n    const program = this.getAndSaveProgram(\n        programKey,\n        () => addsubmuldiv_gpu.getFragmentShaderSource(\n            operandA, aOrientation, opType, operandB, bOrientation));\n\n    const resultTextureShape: [number, number] = [\n      Math.max(aTexShape[0], logicalBTexShape[0]),\n      Math.max(aTexShape[1], logicalBTexShape[1])\n    ];\n\n    const resultTexture =\n        this.textureManager.acquireTexture(resultTextureShape);\n\n    addsubmuldiv_gpu.addSubMulDiv(\n        this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(),\n        bTexShape, resultTexture, resultTextureShape);\n\n    if (cleanupB) {\n      b.dispose();\n    }\n\n    return NDArray.make(\n        resultShape,\n        {texture: resultTexture, textureShapeRC: resultTextureShape});\n  }\n\n  private doGPUShapesMatch(a: NDArray, b: NDArray): boolean {\n    util.assertShapesMatch(a.shape, b.shape);\n    if (a.inGPU()) {\n      // Prefer B to have the shape of A.\n      b.getTextureShapeRC(a.getTextureShapeRC());\n    } else if (b.inGPU()) {\n      // Prefer A to have the shape of B.\n      a.getTextureShapeRC(b.getTextureShapeRC());\n    }\n    return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC());\n  }\n\n  getTextureManager(): TextureManager {\n    return this.textureManager;\n  }\n\n  dispose() {\n    for (const programKey in this.programCache) {\n      if (this.programCache.hasOwnProperty(programKey)) {\n        this.gpgpu.deleteProgram(this.programCache[programKey]);\n      }\n    }\n    this.textureManager.dispose();\n\n    if (this.gpgpuCreatedLocally) {\n      this.gpgpu.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../util';\n\nimport {GPGPUContext} from './webgl/gpgpu_context';\nimport {TextureManager} from './webgl/texture_manager';\nimport * as webgl_util from './webgl/webgl_util';\n\n// These global variables need to be initialized to null so that closure knows\n// not to seal them.\n/** @hidden */\nexport let GPGPU: GPGPUContext = null!;\n/** @hidden */\nexport let TEXTURE_MANAGER: TextureManager = null!;\n\n/** @hidden */\nexport interface NDArrayData {\n  values?: Float32Array;\n  texture?: WebGLTexture;\n  /** [rows, columns] shape of the texture. */\n  textureShapeRC?: [number, number];\n}\n\n/** @hidden */\nexport function initializeGPU(\n    gpgpu: GPGPUContext, textureManager: TextureManager) {\n  GPGPU = gpgpu;\n  TEXTURE_MANAGER = textureManager;\n}\n\nfunction throwIfGPUNotInitialized() {\n  if (GPGPU == null || TEXTURE_MANAGER == null) {\n    throw new Error('GPU not intialized.');\n  }\n}\n\nexport class NDArray {\n  /** The shape of the ndarray. */\n  shape: number[];\n  /** Number of elements in the ndarray. */\n  size: number;\n\n  /**\n   * Number of elements to skip in each dimension when indexing. See\n   * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html\n   */\n  protected strides: number[];\n\n  private data: NDArrayData;\n\n  protected constructor(shape: number[], data: NDArrayData) {\n    // Sanity checks.\n    util.assert(\n        data.values != null || data.texture != null,\n        'Either `values` or `texture` must be defined');\n\n    util.assert(\n        data.texture == null || (data.textureShapeRC != null),\n        '`textureShape` must be defined when `texture` is defined');\n\n    this.size = util.sizeFromShape(shape);\n\n    if (data.values != null) {\n      util.assert(\n          this.size === data.values.length,\n          'Constructing ndarray of shape (' + this.size + ') should match the' +\n              ' length of values (' + data.values.length + ')');\n    }\n\n    this.shape = shape;\n    this.data = data;\n    const dim = this.shape.length;\n\n    if (dim < 2) {\n      this.strides = [];\n    } else {\n      // Last dimension has implicit stride of 1, thus having D-1 (instead of D)\n      // strides.\n      this.strides = new Array(dim - 1);\n      this.strides[dim - 2] = this.shape[dim - 1];\n      for (let i = dim - 3; i >= 0; --i) {\n        this.strides[i] = this.strides[i + 1] * this.shape[i + 1];\n      }\n    }\n  }\n\n  /** Creates a ndarray of zeros with the specified shape. */\n  static zeros<T extends NDArray>(shape: number[]): T {\n    const values = new Float32Array(util.sizeFromShape(shape));\n    return NDArray.make<T>(shape, {values});\n  }\n\n  /** Creates a ndarray of zeros with the same shape as the specified ndarray.\n   */\n  static zerosLike<T extends NDArray>(another: T): T {\n    return NDArray.zeros(another.shape) as T;\n  }\n\n  /** Creates a ndarray with the same values/shape as the specified ndarray. */\n  static like<T extends NDArray>(another: T): T {\n    const values = another.getValues();\n    return NDArray.make<T>(another.shape, {values: new Float32Array(values)});\n  }\n\n  /**\n   * Makes a new ndarray with the provided shape and values. Values should be in\n   * a flat array.\n   */\n  static make<T extends NDArray>(shape: number[], data: NDArrayData): T {\n    switch (shape.length) {\n      case 0:\n        return new Scalar(data) as T;\n      case 1:\n        // tslint:disable-next-line:no-any\n        return new Array1D(data) as any;\n      case 2:\n        // tslint:disable-next-line:no-any\n        return new Array2D(shape as [number, number], data) as any;\n      case 3:\n        // tslint:disable-next-line:no-any\n        return new Array3D(shape as [number, number, number], data) as any;\n      case 4:\n        return new Array4D(\n                   // tslint:disable-next-line:no-any\n                   shape as [number, number, number, number], data) as any;\n      default:\n        // tslint:disable-next-line:no-any\n        return new NDArray(shape, data) as any;\n    }\n  }\n\n  /** Reshapes the current ndarray into the provided shape. */\n  reshape<T extends NDArray>(newShape: number[]): T {\n    if (util.arraysEqual(this.shape, newShape)) {\n      // No-op.\n      // tslint:disable-next-line:no-any\n      return this as any;\n    }\n\n    util.assert(\n        this.size === util.sizeFromShape(newShape),\n        'new shape and old shape must have the same number of elements.');\n\n    return NDArray.make<T>(newShape, this.data);\n  }\n\n  asScalar(): Scalar {\n    util.assert(this.size === 1, 'The array must have only 1 element.');\n    return this.reshape<Scalar>([]);\n  }\n\n  as1D(): Array1D {\n    return this.reshape<Array1D>([this.size]);\n  }\n\n  as2D(rows: number, columns: number): Array2D {\n    return this.reshape<Array2D>([rows, columns]);\n  }\n\n  as3D(rows: number, columns: number, depth: number): Array3D {\n    return this.reshape<Array3D>([rows, columns, depth]);\n  }\n\n  as4D(rows: number, columns: number, depth: number, depth2: number): Array4D {\n    return this.reshape<Array4D>([rows, columns, depth, depth2]);\n  }\n\n  get rank(): number {\n    return this.shape.length;\n  }\n\n  get(...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return this.getValues()[index];\n  }\n\n  add(value: number, ...locs: number[]) {\n    this.set(this.get(...locs) + value, ...locs);\n  }\n\n  set(value: number, ...locs: number[]) {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    this.getValues()[index] = value;\n  }\n\n  locToIndex(locs: number[]): number {\n    let index = locs[locs.length - 1];\n    for (let i = 0; i < locs.length - 1; ++i) {\n      index += this.strides[i] * locs[i];\n    }\n    return index;\n  }\n\n  indexToLoc(index: number): number[] {\n    const locs: number[] = new Array(this.shape.length);\n    for (let i = 0; i < locs.length - 1; ++i) {\n      locs[i] = Math.floor(index / this.strides[i]);\n      index -= locs[i] * this.strides[i];\n    }\n    locs[locs.length - 1] = index;\n    return locs;\n  }\n\n  fill(value: number) {\n    this.getValues().fill(value);\n  }\n\n  getData(): NDArrayData {\n    return this.data;\n  }\n\n  getValues(): Float32Array {\n    if (this.data.values == null) {\n      throwIfGPUNotInitialized();\n      this.data.values = GPGPU.downloadMatrixFromTexture(\n          this.data.texture!, this.data.textureShapeRC![0],\n          this.data.textureShapeRC![1]);\n      this.disposeTexture();\n    }\n    return this.data.values;\n  }\n\n  private uploadToGPU(preferredTexShape?: [number, number]) {\n    throwIfGPUNotInitialized();\n    this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(\n        GPGPU.gl, this.shape, preferredTexShape);\n    this.data.texture =\n        TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC);\n\n    GPGPU.uploadMatrixToTexture(\n        this.data.texture, this.data.textureShapeRC[0],\n        this.data.textureShapeRC[1], this.data.values!);\n\n    this.data.values = null!;\n  }\n\n  getTexture(preferredShapeRC?: [number, number]): WebGLTexture {\n    if (this.data.texture == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.texture!;\n  }\n\n  getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] {\n    if (this.data.textureShapeRC == null) {\n      this.uploadToGPU(preferredShapeRC);\n    }\n    return this.data.textureShapeRC!;\n  }\n\n  dispose(): void {\n    this.data.values = null!;\n    this.shape = null!;\n    if (this.data.texture != null) {\n      this.disposeTexture();\n    }\n  }\n\n  private disposeTexture() {\n    throwIfGPUNotInitialized();\n    TEXTURE_MANAGER.releaseTexture(\n        this.data.texture!, this.data.textureShapeRC!);\n    this.data.texture = null!;\n    this.data.textureShapeRC = null!;\n  }\n\n  inGPU(): boolean {\n    return this.data.texture != null;\n  }\n\n  equals(t: NDArray): boolean {\n    return util.arraysEqual(this.shape, t.shape) &&\n        util.arraysEqual(this.getValues(), t.getValues());\n  }\n\n  static rand<T extends NDArray>(shape: number[], randFunction: () => number):\n      T {\n    const size = util.sizeFromShape(shape);\n    const values = new Float32Array(size);\n    for (let i = 0; i < size; i++) {\n      values[i] = randFunction();\n    }\n\n    return NDArray.make<T>(shape, {values});\n  }\n\n  static randNormal<T extends NDArray>(shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev));\n  }\n\n  static randTruncatedNormal<T extends NDArray>(\n      shape: number[], mean = 0, stdDev = 1) {\n    return NDArray.rand<T>(shape, () => util.randGauss(mean, stdDev, true));\n  }\n\n  static randUniform<T extends NDArray>(shape: number[], a: number, b: number) {\n    return NDArray.rand<T>(shape, () => util.randUniform(a, b));\n  }\n}\n\nexport class Scalar extends NDArray {\n  constructor(data: NDArrayData) {\n    if (data.texture != null) {\n      data.textureShapeRC = [1, 1];\n    }\n    super([], data);\n  }\n\n  static new(value: number) {\n    return new Scalar({values: new Float32Array([value])});\n  }\n\n  static ZERO = Scalar.new(0);\n  static ONE = Scalar.new(1);\n  static TWO = Scalar.new(2);\n  static NEG_ONE = Scalar.new(-1);\n\n  get(): number {\n    return this.getValues()[0];\n  }\n\n  set(value: number) {\n    this.getValues()[0] = value;\n  }\n\n  add(value: number) {\n    this.getValues()[0] += value;\n  }\n}\n\nexport class Array1D extends NDArray {\n  shape: [number];\n\n  constructor(data: NDArrayData) {\n    const shape = (data.values != null) ?\n        [data.values.length] :\n        [util.sizeFromShape(data.textureShapeRC!)];\n    super(shape, data);\n  }\n\n  static new(values: Float32Array|number[]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      util.assert(\n          inferredShape.length === 1,\n          `Error constructing Array1D. Shape of values ${inferredShape} is ` +\n              `not 1 dimensional.`);\n    }\n    return new Array1D({values: toTypedArray(values)});\n  }\n\n  get(i: number): number {\n    return this.getValues()[i];\n  }\n\n  set(value: number, i: number) {\n    this.getValues()[i] = value;\n  }\n\n  add(value: number, i: number) {\n    this.getValues()[i] += value;\n  }\n\n  locToIndex(loc: [number]): number {\n    return loc[0];\n  }\n\n  indexToLoc(index: number): [number] {\n    return [index];\n  }\n\n  static zeros(shape: [number]): Array1D {\n    return NDArray.zeros<Array1D>(shape);\n  }\n}\n\nexport class Array2D extends NDArray {\n  shape: [number, number];\n\n  private stride0: number;\n\n  constructor(shape: [number, number], data: NDArrayData) {\n    util.assert(shape.length === 2, 'Shape should be of length 2');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n  }\n\n  static new(\n      shape: [number, number], values: Float32Array|number[]|number[][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array2D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array2D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number) {\n    return this.getValues()[this.stride0 * i + j];\n  }\n\n  set(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] = value;\n  }\n\n  add(value: number, i: number, j: number) {\n    this.getValues()[this.stride0 * i + j] += value;\n  }\n\n  locToIndex(locs: [number, number]): number {\n    return this.stride0 * locs[0] + locs[1];\n  }\n\n  indexToLoc(index: number): [number, number] {\n    return [Math.floor(index / this.stride0), index % this.stride0];\n  }\n\n  static zeros(shape: [number, number]): Array2D {\n    return NDArray.zeros<Array2D>(shape);\n  }\n}\n\nexport class Array3D extends NDArray {\n  shape: [number, number, number];\n  private stride0: number;\n  private stride1: number;\n\n  constructor(shape: [number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 3, 'Shape should be of length 3');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n  }\n\n  static new(\n      shape: [number, number, number],\n      values: Float32Array|number[]|number[][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array3D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array3D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number) {\n    return this.getValues()[this.stride0 * i + this.stride1 * j + k];\n  }\n\n  set(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number) {\n    this.getValues()[this.stride0 * i + this.stride1 * j + k] += value;\n  }\n\n  locToIndex(locs: [number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2];\n  }\n\n  indexToLoc(index: number): [number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    return [i, Math.floor(index / this.stride1), index % this.stride1];\n  }\n\n  static zeros(shape: [number, number, number]): Array3D {\n    return NDArray.zeros<Array3D>(shape);\n  }\n}\n\nexport class Array4D extends NDArray {\n  shape: [number, number, number, number];\n  private stride0: number;\n  private stride1: number;\n  private stride2: number;\n\n  constructor(shape: [number, number, number, number], data: NDArrayData) {\n    util.assert(shape.length === 4, 'Shape should be of length 4');\n    super(shape, data);\n    this.stride0 = this.strides[0];\n    this.stride1 = this.strides[1];\n    this.stride2 = this.strides[2];\n  }\n\n  static new(\n      shape: [number, number, number, number],\n      values: Float32Array|number[]|number[][][][]) {\n    if (!(values instanceof Float32Array)) {\n      const inferredShape = util.inferShape(values);\n      if (inferredShape.length > 1) {\n        util.assertShapesMatch(\n            shape, inferredShape,\n            `Error when constructing Array4D. Shape of values ` +\n                `${inferredShape} does not match the provided shape ` +\n                `${shape}. `);\n      }\n    }\n    return new Array4D(shape, {values: toTypedArray(values)});\n  }\n\n  get(i: number, j: number, k: number, l: number) {\n    return this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l];\n  }\n\n  set(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value;\n  }\n\n  add(value: number, i: number, j: number, k: number, l: number) {\n    this.getValues()\n        [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value;\n  }\n\n  locToIndex(locs: [number, number, number, number]): number {\n    return this.stride0 * locs[0] + this.stride1 * locs[1] +\n        this.stride2 * locs[2] + locs[3];\n  }\n\n  indexToLoc(index: number): [number, number, number, number] {\n    const i = Math.floor(index / this.stride0);\n    index -= i * this.stride0;\n    const j = Math.floor(index / this.stride1);\n    index -= j * this.stride1;\n    return [i, j, Math.floor(index / this.stride2), index % this.stride2];\n  }\n\n  static zeros(shape: [number, number, number, number]): Array4D {\n    return NDArray.zeros<Array4D>(shape);\n  }\n}\n\ntype ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][];\n\nfunction toTypedArray(a: ArrayData): Float32Array {\n  return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a));\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    uniform sampler2D matrixAScalar;\n    uniform sampler2D matrixBScalar;\n    varying vec2 resultUV;\n\n    const vec2 halfTexel = vec2(0.5, 0.5);\n\n    void main() {\n      float a = texture2D(matrixA, resultUV).r;\n      float b = texture2D(matrixB, resultUV).r;\n      float aScalar = texture2D(matrixAScalar, halfTexel).r;\n      float bScalar = texture2D(matrixBScalar, halfTexel).r;\n      vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n      gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n    }`;\n}\n\nexport function addScaledMatrices(\n    gpgpu: GPGPUContext, addScaledMatricesProgram: WebGLProgram,\n    a: WebGLTexture, b: WebGLTexture, rows: number, columns: number,\n    aScalar: WebGLTexture, bScalar: WebGLTexture, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(addScaledMatricesProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2);\n  gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3);\n  gpgpu.executeProgram();\n}\n\nexport function uploadAddScaledMatricesDownload(\n    a: Float32Array, b: Float32Array, rows: number, columns: number,\n    aScalar: number, bScalar: number): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource());\n\n  const aTex = gpgpu.createMatrixTexture(rows, columns);\n  const bTex = gpgpu.createMatrixTexture(rows, columns);\n  const aScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const bScalarTex = gpgpu.createMatrixTexture(1, 1);\n  const resultTex = gpgpu.createMatrixTexture(rows, columns);\n\n  gpgpu.uploadMatrixToTexture(aTex, rows, columns, a);\n  gpgpu.uploadMatrixToTexture(bTex, rows, columns, b);\n  gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar]));\n  gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar]));\n\n  addScaledMatrices(\n      gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex,\n      resultTex);\n\n  const result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns);\n\n  gpgpu.deleteMatrixTexture(aTex);\n  gpgpu.deleteMatrixTexture(bTex);\n  gpgpu.deleteMatrixTexture(resultTex);\n  gpgpu.deleteMatrixTexture(aScalarTex);\n  gpgpu.deleteMatrixTexture(bScalarTex);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\n\nimport * as binaryop_gpu from './binaryop_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport type Operation = '+' | '-' | '*' | '/';\n\nexport enum OperandType {\n  MATRIX,\n  SCALAR\n}\n\nexport function getFragmentShaderSource(\n    aType: OperandType, aOrientation: MatrixOrientation, op: Operation,\n    bType: OperandType, bOrientation: MatrixOrientation): string {\n  const aUV = operandToShaderSnippet(aType, aOrientation);\n  const bUV = operandToShaderSnippet(bType, bOrientation);\n  const resultOp = `gl_FragColor = vec4(a ${op} b, 0, 0, 0);`;\n  return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp);\n}\n\nfunction operandToShaderSnippet(\n    operand: OperandType, orientation: MatrixOrientation): string {\n  switch (operand) {\n    case OperandType.MATRIX:\n      return 'resultUV' +\n          (orientation === MatrixOrientation.REGULAR ? '.st' : '.ts');\n    case OperandType.SCALAR:\n      return 'vec2(0.5, 0.5)';\n    default:\n      throw new Error('Unknown operand type');\n  }\n}\n\nexport function addSubMulDiv(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  return binaryop_gpu.binaryOp(\n      gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result,\n      resultShapeRowCol);\n}\n\nexport function uploadScalarPlusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '+', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixMinusScalarDownload(\n    a: Float32Array, aShape: [number, number], b: number,\n    aOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR,\n      MatrixOrientation.REGULAR);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      a, aShape, new Float32Array([b]), [1, 1], src);\n}\n\nexport function uploadScalarMinusMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '-', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadScalarTimesMatrixDownload(\n    a: number, b: Float32Array, bShape: [number, number],\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.SCALAR, MatrixOrientation.REGULAR, '*', OperandType.MATRIX,\n      bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(\n      new Float32Array([a]), [1, 1], b, bShape, src);\n}\n\nexport function uploadMatrixTimesMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n\nexport function uploadMatrixPlusMatrixDownload(\n    a: Float32Array, b: Float32Array, shape: [number, number],\n    aOrientation = MatrixOrientation.REGULAR,\n    bOrientation = MatrixOrientation.REGULAR): Float32Array {\n  const src = getFragmentShaderSource(\n      OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation);\n  return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as argminmax_gpu from './argminmax_gpu';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      float argMaxA = getArgMinMax(matrixA);\n      float argMaxB = getArgMinMax(matrixB);\n      float value;\n      if (isNaN(argMaxA)) {\n        value = argMaxA;\n      } else if (isNaN(argMaxB)) {\n        value = argMaxB;\n      } else {\n        value = float(argMaxA == argMaxB);\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getArgMaxEqualsFragmentShaderSource(\n    rows: number, columns: number): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function argMaxEquals(\n    gpgpu: GPGPUContext, maxEqualsProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, numRows: number, numCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(maxEqualsProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;`;\n}\n\nfunction getFragmentShaderMainSource(): string {\n  return `\n    void main() {\n      gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n    }`;\n}\n\nfunction getArgMinMaxFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return [\n    getFragmentShaderPrologueSource(),\n    getFragmentShaderGetArgMinMaxSource(compOp, rows, columns),\n    getFragmentShaderMainSource()\n  ].join('\\n');\n}\n\nexport function getArgMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '<');\n}\n\nexport function getArgMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getArgMinMaxFragmentShaderSource(rows, columns, '>');\n}\n\nexport function getFragmentShaderGetArgMinMaxSource(\n    compOp: string, rows: number, columns: number) {\n  return `\n    const vec2 dimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    float getArgMinMax(in sampler2D matrix) {\n      vec2 bestCR = vec2(0, 0);\n      float bestValue = texture2D(matrix, bestCR).r;\n\n      for (float c = 0.0; c < dimCR.x; c += 1.0) {\n        for (float r = 0.0; r < dimCR.y; r += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / dimCR;\n          float value = texture2D(matrix, uv).r;\n          if (isNaN(value)) {\n            return value;\n          }\n          if (value ${compOp} bestValue) {\n            bestValue = value;\n            bestCR = cr;\n          }\n        }\n      }\n      return bestCR.x + (bestCR.y * dimCR.x);\n    }\n  `;\n}\n\nexport function argMinMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderAvgPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'avg', false);\n}\n\nexport function avgPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    xTexShapeRC: [number, number], meanTexShapeRC: [number, number],\n    varianceTexShapeRC: [number, number],\n    offsetTexShapeRC: [number, number]|null,\n    scaleTexShapeRC?: [number, number]|null, varianceEpsilon = 0.001): string {\n  let offsetSamplerSnippet = '';\n  let offsetShapeInitializationSnippet = '';\n  let offsetCoordsSnippet = '';\n  let offsetUVSnippet = '';\n  let offsetValueSnippet = '';\n  let offsetOperationSnippet = '0.0';\n\n  let scaleSamplerSnippet = '';\n  let scaleShapeInitializationSnippet = '';\n  let scaleCoordsSnippet = '';\n  let scaleUVSnippet = '';\n  let scaleValueSnippet = '';\n  let scaleOperationSnippet = '';\n\n  if (offsetTexShapeRC != null) {\n    offsetSamplerSnippet = 'uniform sampler2D offset;';\n    offsetShapeInitializationSnippet = `const vec2 offsetShapeCR = vec2(\n            ${offsetTexShapeRC[1]}, ${offsetTexShapeRC[0]});`;\n    offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);';\n    offsetUVSnippet =\n        'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;';\n    offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;';\n    offsetOperationSnippet = 'offsetValue';\n  }\n\n  if (scaleTexShapeRC != null) {\n    scaleSamplerSnippet = 'uniform sampler2D scale;';\n    scaleShapeInitializationSnippet = `const vec2 scaleShapeCR = vec2(\n            ${scaleTexShapeRC[1]}, ${scaleTexShapeRC[0]});`;\n    scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);';\n    scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;';\n    scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;';\n    scaleOperationSnippet = 'inv *= scaleValue;';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D mean;\n    uniform sampler2D variance;\n    ${offsetSamplerSnippet}\n    ${scaleSamplerSnippet}\n\n    varying vec2 resultUV;\n\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 meanShapeCR = vec2(${meanTexShapeRC[1]}, ${meanTexShapeRC[0]});\n    const vec2 varianceShapeCR = vec2(\n        ${varianceTexShapeRC[1]}, ${varianceTexShapeRC[0]});\n\n    ${offsetShapeInitializationSnippet}\n    ${scaleShapeInitializationSnippet}\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const float varianceEpsilon = ${varianceEpsilon};\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n      vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n      ${offsetCoordsSnippet}\n      ${scaleCoordsSnippet}\n\n      vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n      vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n      ${offsetUVSnippet}\n      ${scaleUVSnippet}\n\n      float xValue = texture2D(x, resultUV).r;\n      float meanValue = texture2D(mean, meanUV).r;\n      float varianceValue = texture2D(variance, varianceUV).r;\n      ${offsetValueSnippet}\n      ${scaleValueSnippet}\n\n      float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n      ${scaleOperationSnippet}\n      float xTimesInv = xValue * inv;\n      float meanTimesInvWithOffset = ${offsetOperationSnippet}\n          - meanValue * inv;\n\n      gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n    }`;\n}\n\nexport function batchNormalization(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    xShapeRowCol: [number, number], mean: WebGLTexture,\n    meanShapeRowCol: [number, number], variance: WebGLTexture,\n    varianceShapeRowCol: [number, number], offset: WebGLTexture|null,\n    offsetShapeRowCol: [number, number]|null, scale: WebGLTexture|null,\n    scaleShapeRowCol: [number, number]|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.setInputMatrixTexture(mean, 'mean', 1);\n  gpgpu.setInputMatrixTexture(variance, 'variance', 2);\n  let nextIndex = 3;\n  if (offset != null) {\n    gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex);\n    nextIndex++;\n  }\n  if (scale != null) {\n    gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    aResultUV: string, bResultUV: string, op: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform sampler2D matrixB;\n    varying vec2 resultUV;\n\n    void main() {\n      float a = texture2D(matrixA, ${aResultUV}).r;\n      float b = texture2D(matrixB, ${bResultUV}).r;\n      ${op}\n    }`;\n}\n\nexport function binaryOp(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    aShapeRowCol: [number, number], b: WebGLTexture,\n    bShapeRowCol: [number, number], result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n\nexport function uploadBinaryOpDownload(\n    a: Float32Array, aShape: [number, number], b: Float32Array,\n    bShape: [number, number], fragmentShaderSource: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(fragmentShaderSource);\n\n  const aTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(aShape[0], aShape[1]);\n  const bTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(bShape[0], bShape[1]);\n\n  const resultShape: [number, number] =\n      [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])];\n\n  const resultTexture: WebGLTexture =\n      gpgpu.createMatrixTexture(resultShape[0], resultShape[1]);\n\n  gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a);\n  gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b);\n\n  binaryOp(\n      gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture,\n      resultShape);\n  const result = gpgpu.downloadMatrixFromTexture(\n      resultTexture, resultShape[0], resultShape[1]);\n\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(bTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    x1ShapeRCD: [number, number, number], x2ShapeRCD: [number, number, number],\n    resultShapeRCD: [number, number, number], axis: number): string {\n  const x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD);\n  const x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD);\n\n  const yAxes = ['yR', 'yC', 'yD'];\n  const concatAxis = yAxes[axis];\n\n  return `\n    precision highp float;\n    uniform sampler2D x1;\n    uniform sampler2D x2;\n\n    const vec2 x1ShapeCR = vec2(${x1TexShapeRC[1]}, ${x1TexShapeRC[0]});\n    const vec2 x2ShapeCR = vec2(${x2TexShapeRC[1]}.0, ${x2TexShapeRC[0]}.0);\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${resultShapeRCD[2]}.0);\n      float yD = mod(yTexCR.x, ${resultShapeRCD[2]}.0);\n\n      float value = 0.0;\n\n      if (${concatAxis} < ${x1ShapeRCD[axis]}.0) {\n        // Map yR, yC, yD back to x1 coordinates.\n        vec2 x1CR = vec2(yC * ${x1ShapeRCD[2]}.0 + yD, yR);\n        vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n        value = texture2D(x1, x1UV).r;\n      } else {\n        ${concatAxis} = ${concatAxis} - ${x1ShapeRCD[axis]}.0;\n\n        // Map yR, yC, yD back to x2 coordinates.\n        vec2 x2CR = vec2(yC * ${x2ShapeRCD[2]}.0 + yD, yR);\n        vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n        value = texture2D(x2, x2UV).r;\n      }\n\n      gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function concat3D(\n    gpgpu: GPGPUContext, program: WebGLProgram, x1: WebGLTexture,\n    x2: WebGLTexture, result: WebGLTexture, resultShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x1, 'x1', 0);\n  gpgpu.setInputMatrixTexture(x2, 'x2', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport * as conv_gpu from './conv_gpu';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderDerWeightsSource(\n    xShapeRowColDepth: [number, number, number], fSize: number,\n    outputDepth: number, stride: number, zeroPad: number) {\n  const getMatrixValueOrZeroPad =\n      conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const inputDepth = xShapeRowColDepth[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth);\n\n  const yShape = conv_util.computeOutputShape3D(\n      xShapeRowColDepth, fSize, outputDepth, stride, zeroPad);\n  const yNumRows = yShape[0];\n  const yNumCols = yShape[1];\n  const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape);\n\n  const fSizeTimesInputDepth = fSize * inputDepth;\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D dy;\n  `;\n\n  return prologue + '\\n' + getMatrixValueOrZeroPad + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]});\n\n    void main() {\n      vec2 wTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n      float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0);\n      float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0;\n      float wC = floor(wTexRLeftover / ${inputDepth}.0);\n      float d1 = mod(wTexRLeftover, ${inputDepth}.0);\n      float d2 = wTexCR.x;\n\n      // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float xR = wR + yR * ${stride}.0 - ${zeroPad}.0;\n        float xTexR = xR;\n        float yTexR = yR;\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          float xC = wC + yC * ${stride}.0 - ${zeroPad}.0;\n\n          // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) +\n                        vec2(d1, d2);\n          float xTexC = xyTexC.x;\n          float yTexC = xyTexC.y;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read x(xR, xC, d1) (potentially zero-padded).\n          float xValue =\n            getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n          dotProd += (xValue * dyValue);\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderConvTransposeSource(\n    xShapeRCD: [number, number, number], fSize: number, origInputDepth: number,\n    origStride: number, origPad: number, hasBias: boolean) {\n  const pad = fSize - 1 - origPad;\n  const [xRows, xCols, origOutputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize);\n\n  const getBiasValue = hasBias ?\n      conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) :\n      '';\n  const biasPrologue = hasBias ? 'uniform sampler2D biases;' : '';\n  const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : '';\n\n  const prologue = `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    ${biasPrologue}\n    `;\n\n  return prologue + '\\n' + getBiasValue + '\\n' +\n      `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${origInputDepth}.0);\n      float d2 = mod(yTexCR.x, ${origInputDepth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float xR = (xRCorner + wR) / ${origStride}.0;\n        // TODO(smilkov): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) {\n          continue;\n        }\n\n        float wRPerm = ${fSize}.0 - 1.0 - wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float xC = (xCCorner + wC) / ${origStride}.0;\n          if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) {\n            continue;\n          }\n\n          float wCPerm = ${fSize}.0 - 1.0 - wC;\n          float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 +\n                        wCPerm * ${origInputDepth}.0 + d2;\n\n          for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${origOutputDepth}.0 + d1;\n            float wTexC = d1;\n\n            // Read x(xR, xC, d1).\n            vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n            float xValue = texture2D(x, xUV).r;\n\n            // Read w(wRPerm, wCPerm, d2, d1).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      ${biasOperation}\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderDerBiasSource(\n    dyShapeRCD: [number, number, number]) {\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n  const [yNumRows, yNumCols, outputDepth] = dyShapeRCD;\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n      // The bias texture RC shape is [1, d2].\n      float d2 = biasTexCR.x;\n\n      float derBias = 0.0;\n      for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) {\n        float yTexR = yR;\n\n        for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) {\n          // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n          float yTexC = yC * ${outputDepth}.0 + d2;\n\n          // Read dy(yR, yC, d2).\n          vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          derBias += dyValue;\n        }\n      }\n      gl_FragColor = vec4(derBias, 0, 0, 0);\n    }`;\n}\n\nexport function derBias(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    result: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.executeProgram();\n}\n\nexport function derWeights(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    dyTex: WebGLTexture, result: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 1);\n  gpgpu.executeProgram();\n}\n\nexport function convTranspose(\n    gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture,\n    weightsTex: WebGLTexture, biasesTex: WebGLTexture|null,\n    resultTex: WebGLTexture, resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(xTex, 'x', 0);\n  gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1);\n  if (biasesTex != null) {\n    gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderPrologueSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    uniform sampler2D weights;\n    uniform sampler2D biases;\n    varying vec2 resultUV;`;\n}\n\nexport function getFragmentShaderGetMatrixValueOrZeroPadSource(): string {\n  return `\n    float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n        vec2 requestedCR) {\n      vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n      float value = texture2D(matrix, uv).r;\n      bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n      bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n      bool outside = lessThanZero || greaterThanOne;\n      return mix(value, 0.0, float(outside));\n    }`;\n}\n\nexport function getFragmentShaderConvolveSource(\n    xShapeRCD: [number, number, number], fSize: number, outputDepth: number,\n    stride: number, pad: number, hasBias: boolean) {\n  const [xRows, xCols, inputDepth] = xShapeRCD;\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n  const wTexShapeRC =\n      conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize);\n\n  return `\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n    const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]});\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${outputDepth}.0);\n      float d2 = mod(yTexCR.x, ${outputDepth}.0);\n      float wTexC = d2;\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n\n          for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) {\n            float xTexC = xC * ${inputDepth}.0 + d1;\n            float wTexR = wR * ${fSize * inputDepth}.0 +\n                wC * ${inputDepth}.0 + d1;\n\n            float xValue =\n                getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n            // Read w(wR, wC, d1, d2).\n            vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n            float wValue = texture2D(weights, wUV).r;\n\n            dotProd += xValue * wValue;\n          }\n        }\n      }\n      if (${hasBias}) {\n        dotProd += getBiasValue(biases, d2);\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function getFragmentShaderGetBiasValueSource(outputDepth: number):\n    string {\n  return `\n    float getBiasValue(in sampler2D bias, float biasC) {\n      const vec2 biasShapeCR = vec2(${outputDepth}, 1);\n      vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0);\n      vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n      return texture2D(bias, biasUV).r;\n    }`;\n}\n\nexport function getFragmentShaderSource(\n    aShapeRowColDepth: [number, number, number], resultDepth: number,\n    fieldSize: number, stride: number, zeroPad: number,\n    hasBias: boolean): string {\n  const aShapeRC: [number, number] =\n      conv_util.computeTexShapeFrom3D(aShapeRowColDepth);\n\n  const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape(\n      aShapeRowColDepth[2], resultDepth, fieldSize);\n\n  const prologue = getFragmentShaderPrologueSource();\n  const getMatrixValueOrZeroPad =\n      getFragmentShaderGetMatrixValueOrZeroPadSource();\n  const convolve = getFragmentShaderConvolveSource(\n      aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias);\n  const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth);\n\n  return [\n    prologue,\n    getMatrixValueOrZeroPad,\n    getBiasValue,\n    convolve,\n  ].join('\\n');\n}\n\nexport function convolve(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture,\n    weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture,\n    resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(a, 'x', 0);\n  gpgpu.setInputMatrixTexture(weights, 'weights', 1);\n  if (biases != null) {\n    gpgpu.setInputMatrixTexture(biases, 'biases', 2);\n  }\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(\n    sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number],\n    destSizeRowCol: [number, number]): string {\n  return `\n    precision highp float;\n    uniform sampler2D source;\n    uniform vec2 sourceStartCR;\n    uniform vec2 destStartCR;\n\n    const vec2 sourceShapeCR =\n      vec2(${sourceShapeRowCol[1]}, ${sourceShapeRowCol[0]});\n    const vec2 sourceSizeCR =\n      vec2(${sourceSizeRowCol[1]}, ${sourceSizeRowCol[0]});\n    const vec2 destSizeCR =\n      vec2(${destSizeRowCol[1]}, ${destSizeRowCol[0]});\n\n    void main() {\n      vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n      float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n      vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n        floor(destOffsetFlat / sourceSizeCR.x));\n      vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n      vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n      gl_FragColor = texture2D(source, sourceUV);\n    }`;\n}\n\nexport function copy(\n    gpgpu: GPGPUContext, program: WebGLProgram, source: WebGLTexture,\n    sourceShapeRowCol: [number, number], sourceStartRowCol: [number, number],\n    sourceSizeRowCol: [number, number], dest: WebGLTexture,\n    destShapeRowCol: [number, number], destStartRowCol: [number, number],\n    destSizeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]);\n  gpgpu.setOutputMatrixWriteRegion(\n      destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1],\n      destSizeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(source, 'source', 0);\n  const sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR');\n  gpgpu.gl.uniform2f(\n      sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]);\n  const destStartCRLoc = gpgpu.getUniformLocation('destStartCR');\n  gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getExpUnaryOp(): string {\n  return 'gl_FragColor = vec4(exp(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp());\n}\n\nexport function exp(\n    gpgpu: GPGPUContext, expProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result);\n}\n\nexport function uploadExpDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as gpgpu_util from './gpgpu_util';\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nimport {WebGLLoseContextExtension} from './webgl_util';\n\nexport class GPGPUContext {\n  gl: WebGLRenderingContext;\n  textureFloatExtension: {};\n  colorBufferFloatExtension: {};\n  loseContextExtension: WebGLLoseContextExtension;\n  vertexBuffer: WebGLBuffer;\n  indexBuffer: WebGLBuffer;\n  framebuffer: WebGLFramebuffer;\n  outputTexture: WebGLTexture|null = null;\n  program: WebGLProgram|null = null;\n  private disposed = false;\n  private autoDebugValidate = false;\n\n  constructor(gl?: WebGLRenderingContext) {\n    if (gl != null) {\n      this.gl = gl;\n    } else {\n      this.gl = gpgpu_util.createWebGLContext();\n    }\n\n    // WebGL 2.0 enables texture floats without an extension.\n    if (!webgl_util.isWebGL2Enabled()) {\n      this.textureFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float');\n    } else {\n      this.colorBufferFloatExtension =\n          webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float');\n    }\n\n    this.loseContextExtension =\n        webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as\n        WebGLLoseContextExtension;\n    this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl);\n    this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl);\n    this.framebuffer = webgl_util.createFramebuffer(this.gl);\n  }\n\n  public dispose() {\n    this.throwIfDisposed();\n    if (this.program != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound WebGLProgram.' +\n          ' This is probably a resource leak, delete the program with ' +\n          'GPGPUContext.deleteProgram before disposing.');\n    }\n    if (this.outputTexture != null) {\n      console.warn(\n          'Disposing a GPGPUContext that still has a bound output matrix ' +\n          'texture.  This is probably a resource leak, delete the output ' +\n          'matrix texture with GPGPUContext.deleteMatrixTexture before ' +\n          'disposing.');\n    }\n    const gl = this.gl;\n    webgl_util.callAndCheck(gl, () => gl.finish());\n    webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer));\n    webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer));\n    webgl_util.callAndCheck(\n        gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null));\n    webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer));\n    this.loseContextExtension.loseContext();\n    this.disposed = true;\n  }\n\n  public enableAutomaticDebugValidation(enabled: boolean) {\n    this.autoDebugValidate = enabled;\n    webgl_util.enableDebugWebGLErrorChecking(enabled);\n  }\n\n  public createMatrixTexture(rows: number, columns: number): WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createMatrixTexture(this.gl, rows, columns);\n  }\n\n  public uploadPixelDataToTexture(\n      texture: WebGLTexture,\n      pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n    this.throwIfDisposed();\n    gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels);\n  }\n\n  public createPackedMatrixTexture(rows: number, columns: number):\n      WebGLTexture {\n    this.throwIfDisposed();\n    return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns);\n  }\n\n  public deleteMatrixTexture(texture: WebGLTexture) {\n    this.throwIfDisposed();\n    if (this.outputTexture === texture) {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n      this.outputTexture = null;\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture));\n  }\n\n  public uploadMatrixToTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    const numChannels = 1;\n    return gpgpu_util.uploadMatrixToTexture(\n        this.gl, texture, rows, columns, matrix, numChannels);\n  }\n\n  public uploadMatrixToPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number,\n      matrix: Float32Array) {\n    this.throwIfDisposed();\n    return gpgpu_util.uploadMatrixToPackedTexture(\n        this.gl, texture, rows, columns, matrix);\n  }\n\n  public downloadMatrixFromTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () =>\n            gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns));\n  }\n\n  public downloadMatrixFromPackedTexture(\n      texture: WebGLTexture, rows: number, columns: number): Float32Array {\n    return this.downloadMatrixDriver(\n        texture,\n        () => gpgpu_util.downloadMatrixFromPackedOutputTexture(\n            this.gl, rows, columns));\n  }\n\n  public createProgram(fragmentShaderSource: string): WebGLProgram {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    const fragmentShader: WebGLShader =\n        webgl_util.createFragmentShader(gl, fragmentShaderSource);\n    const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl);\n    const program: WebGLProgram = webgl_util.createProgram(gl);\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader));\n    webgl_util.linkProgram(gl, program);\n    if (this.autoDebugValidate) {\n      webgl_util.validateProgram(gl, program);\n    }\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader));\n    webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader));\n    webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader));\n    return program;\n  }\n\n  public deleteProgram(program: WebGLProgram) {\n    this.throwIfDisposed();\n    if (program === this.program) {\n      this.program = null;\n    }\n    if (program != null) {\n      webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program));\n    }\n  }\n\n  public setProgram(program: WebGLProgram|null) {\n    this.throwIfDisposed();\n    this.program = program;\n    if ((this.program != null) && this.autoDebugValidate) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program));\n  }\n\n  public getUniformLocation(uniformName: string): WebGLUniformLocation {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    return webgl_util.getProgramUniformLocationOrThrow(\n        this.gl, this.program!, uniformName);\n  }\n\n  public setInputMatrixTexture(\n      inputMatrixTexture: WebGLTexture, uniformName: string,\n      textureUnit: number) {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    webgl_util.bindTextureToProgramUniformSampler(\n        this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit);\n  }\n\n  public setOutputMatrixTexture(\n      outputMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows);\n  }\n\n  public setOutputPackedMatrixTexture(\n      outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) {\n    this.throwIfDisposed();\n    const [width, height] =\n        tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n    this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height);\n  }\n\n  public setOutputMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    this.setOutputMatrixWriteRegionDriver(\n        startColumn, startRow, numColumns, numRows);\n  }\n\n  public setOutputPackedMatrixWriteRegion(\n      startRow: number, numRows: number, startColumn: number,\n      numColumns: number) {\n    throw new Error('setOutputPackedMatrixWriteRegion not implemented.');\n  }\n\n  public debugValidate() {\n    if (this.program != null) {\n      webgl_util.validateProgram(this.gl, this.program);\n    }\n    webgl_util.validateFramebuffer(this.gl);\n  }\n\n  public executeProgram() {\n    this.throwIfDisposed();\n    this.throwIfNoProgram();\n    const gl = this.gl;\n    gpgpu_util.bindVertexProgramAttributeStreams(\n        gl, this.program!, this.vertexBuffer);\n    if (this.autoDebugValidate) {\n      this.debugValidate();\n    }\n    webgl_util.callAndCheck(\n        gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0));\n  }\n\n  public blockUntilAllProgramsCompleted() {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(this.gl, () => this.gl.finish());\n  }\n\n  private downloadMatrixDriver(\n      texture: WebGLTexture,\n      downloadAndDecode: () => Float32Array): Float32Array {\n    this.throwIfDisposed();\n    webgl_util.bindColorTextureToFramebuffer(\n        this.gl, texture, this.framebuffer);\n    const result = downloadAndDecode();\n    if (this.outputTexture != null) {\n      webgl_util.bindColorTextureToFramebuffer(\n          this.gl, this.outputTexture, this.framebuffer);\n      if (this.autoDebugValidate) {\n        webgl_util.validateFramebuffer(this.gl);\n      }\n    } else {\n      webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer);\n    }\n    return result;\n  }\n\n  private setOutputMatrixTextureDriver(\n      outputMatrixTextureMaybePacked: WebGLTexture, width: number,\n      height: number) {\n    this.throwIfDisposed();\n    const gl = this.gl;\n    webgl_util.bindColorTextureToFramebuffer(\n        gl, outputMatrixTextureMaybePacked, this.framebuffer);\n    if (this.autoDebugValidate) {\n      webgl_util.validateFramebuffer(gl);\n    }\n    this.outputTexture = outputMatrixTextureMaybePacked;\n    webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height));\n    webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height));\n  }\n\n  private setOutputMatrixWriteRegionDriver(\n      x: number, y: number, width: number, height: number) {\n    this.throwIfDisposed();\n    webgl_util.callAndCheck(\n        this.gl, () => this.gl.scissor(x, y, width, height));\n  }\n\n  private throwIfDisposed() {\n    if (this.disposed) {\n      throw new Error('Attempted to use disposed GPGPUContext.');\n    }\n  }\n\n  private throwIfNoProgram() {\n    if (this.program == null) {\n      throw new Error('No GPU program is currently set.');\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as tex_util from './tex_util';\nimport * as webgl_util from './webgl_util';\n\nexport function getWebGLContextAttributes(): WebGLContextAttributes {\n  return {\n    alpha: false,\n    antialias: false,\n    premultipliedAlpha: false,\n    preserveDrawingBuffer: false,\n    depth: false,\n    stencil: false,\n    failIfMajorPerformanceCaveat: true\n  };\n}\n\nexport function createWebGLContext(canvas?: HTMLCanvasElement) {\n  const attributes = getWebGLContextAttributes();\n  let gl: WebGLRenderingContext;\n  if (canvas != null) {\n    gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes);\n  } else {\n    gl = webgl_util.createWebGLRenderingContext(attributes);\n  }\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL));\n  webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST));\n  webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE));\n  webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK));\n  return gl;\n}\n\nexport function createVertexShader(gl: WebGLRenderingContext): WebGLShader {\n  const vertexShaderSource = `\n    precision highp float;\n    attribute vec3 clipSpacePos;\n    attribute vec2 uv;\n    varying vec2 resultUV;\n\n    void main() {\n      gl_Position = vec4(clipSpacePos, 1);\n      resultUV = uv;\n    }`;\n  return webgl_util.createVertexShader(gl, vertexShaderSource);\n}\n\nexport function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // [x y z u v] * [upper-left, lower-left, upper-right, lower-right]\n  const vertexArray = new Float32Array(\n      [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]);\n  return webgl_util.createStaticVertexBuffer(gl, vertexArray);\n}\n\nexport function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer {\n  // OpenGL (and WebGL) have \"CCW == front\" winding\n  const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]);\n  return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices);\n}\n\nfunction getTextureInternalFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled()) {\n    if (numChannels === 4) {\n      // tslint:disable-next-line:no-any\n      return (gl as any).RGBA32F;\n    }\n    // tslint:disable-next-line:no-any\n    return (gl as any).R32F;\n  }\n  return gl.RGBA;\n}\n\nfunction getTextureFormat(\n    gl: WebGLRenderingContext, numChannels: number): number {\n  if (webgl_util.isWebGL2Enabled() && numChannels === 1) {\n    // tslint:disable-next-line:no-any\n    return (gl as any).RED;\n  }\n  return gl.RGBA;\n}\n\nfunction createAndConfigureTexture(\n    gl: WebGLRenderingContext, width: number, height: number,\n    numChannels: number): WebGLTexture {\n  webgl_util.validateTextureSize(gl, width, height);\n  const texture = webgl_util.createTexture(gl);\n\n  const tex2d = gl.TEXTURE_2D;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  const format = getTextureFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n  return texture;\n}\n\nexport function createMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 1;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createColorMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function createPackedMatrixTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture {\n  const [width, height] =\n      tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const numChannels = 4;\n  return createAndConfigureTexture(gl, width, height, numChannels);\n}\n\nexport function bindVertexProgramAttributeStreams(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    vertexBuffer: WebGLBuffer) {\n  const posOffset = 0;               // x is the first buffer element\n  const uvOffset = 3 * 4;            // uv comes after [x y z]\n  const stride = (3 * 4) + (2 * 4);  // xyz + uv, each entry is 4-byte float.\n  webgl_util.callAndCheck(\n      gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer));\n  webgl_util.bindVertexBufferToProgramAttribute(\n      gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset);\n  try {\n    webgl_util.bindVertexBufferToProgramAttribute(\n        gl, program, 'uv', vertexBuffer, 2, stride, uvOffset);\n  } catch (e) {\n    // Programs with 1x1 output textures don't use the uv attribute.\n    // This can cause the shader linker to dead-strip it, so we shouldn't\n    // complain or fail if it's not present.\n    if (!e.hasOwnProperty('namedVertexAttributeNotFound')) {\n      throw e;\n    }\n  }\n}\n\nexport function uploadPixelDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) {\n  const numChannels = 4;\n  const internalFormat = getTextureInternalFormat(gl, numChannels);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texImage2D(\n          gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nfunction uploadDataToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, width: number,\n    height: number, data: Float32Array, numChannels: number) {\n  const textureFormat = getTextureFormat(gl, numChannels);\n\n  webgl_util.validateTextureSize(gl, width, height);\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n  webgl_util.callAndCheck(\n      gl,\n      () => gl.texSubImage2D(\n          gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT,\n          data));\n  webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function uploadMatrixToTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array, numChannels: number) {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture =\n      numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          matrix.length, channelsPerTexture));\n  tex_util.encodeMatrixToUnpackedArray(\n      matrix, unpackedArray, channelsPerTexture);\n\n  uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels);\n}\n\nexport function uploadMatrixToPackedTexture(\n    gl: WebGLRenderingContext, texture: WebGLTexture, rows: number,\n    columns: number, matrix: Float32Array) {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA);\n  const numChannels = 4;\n  uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels);\n}\n\nexport function downloadMatrixFromOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] =\n      tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  const channelsPerTexture = 4;\n  const unpackedArray =\n      new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(\n          rows * columns, channelsPerTexture));\n  const textureFormat = getTextureFormat(gl, channelsPerTexture);\n\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray));\n\n  const matrix = new Float32Array(rows * columns);\n  tex_util.decodeMatrixFromUnpackedArray(\n      unpackedArray, matrix, channelsPerTexture);\n  return matrix;\n}\n\nexport function downloadMatrixFromPackedOutputTexture(\n    gl: WebGLRenderingContext, rows: number, columns: number): Float32Array {\n  const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const packedRGBA = new Float32Array(\n      tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns));\n  webgl_util.callAndCheck(\n      gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA));\n  const matrix = new Float32Array(rows * columns);\n  return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix);\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getLogUnaryOp(): string {\n  return 'gl_FragColor = vec4(log(value), 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp());\n}\n\nexport function log(\n    gpgpu: GPGPUContext, logProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result);\n}\n\nexport function uploadLogDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          aMax = max(aMax, aCur);\n        }\n      }\n\n      float expSum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          float aCur = texture2D(matrixA, uv).r;\n          expSum += exp(aCur - aMax);\n        }\n      }\n\n      gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n    }`;\n}\n\nexport function logSumExp(\n    gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(logSumExpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadLogSumExpDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result[0];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderMaxPoolBackprop(\n    dyShapeRCD: [number, number, number], fSize: number, origStride: number,\n    origPad: number) {\n  const origInputDepth = dyShapeRCD[2];\n  const pad = fSize - 1 - origPad;\n  const [dyRows, dyCols, depth] = dyShapeRCD;\n\n  const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD);\n\n  return `\n    precision highp float;\n    uniform sampler2D dy;\n    uniform sampler2D maxPos;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]});\n\n    void main() {\n      vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n      float dxR = dxTexCR.y;\n      float dxC = floor(dxTexCR.x / ${origInputDepth}.0);\n      float d = mod(dxTexCR.x, ${origInputDepth}.0);\n\n      vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0);\n      float dyRCorner = dyRCCorner.x;\n      float dyCCorner = dyRCCorner.y;\n\n      // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n      // ? = to be determined. : = across all values in that axis.\n      float dotProd = 0.0;\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n\n        float dyR = (dyRCorner + wR) / ${origStride}.0;\n        // TODO(nsthorat): Splice this with another version where you call\n        // getMatrixValueOrZeroPad(). Here and below.\n        if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) {\n          continue;\n        }\n\n        float dyTexR = dyR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n\n          float dyC = (dyCCorner + wC) / ${origStride}.0;\n          if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) {\n            continue;\n          }\n\n          float dyTexC = dyC * ${depth}.0 + d;\n\n          // Read dy(dyR, dyC, d).\n          vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n          float dyValue = texture2D(dy, dyUV).r;\n\n          // Read maxPos(dyR, dyC, d).\n          float maxPosValue =\n              ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r;\n\n          // Get the current value, check it against the value from the\n          // position matrix.\n          float curPosValue = wR * ${fSize}.0 + wC;\n          float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n          dotProd += dyValue * mask;\n        }\n      }\n      gl_FragColor = vec4(dotProd, 0, 0, 0);\n    }`;\n}\n\nexport function maxPoolBackprop(\n    gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture,\n    maxPositionsTex: WebGLTexture, resultTex: WebGLTexture,\n    resultTexShapeRC: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      resultTex, resultTexShapeRC[0], resultTexShapeRC[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(dyTex, 'dy', 0);\n  gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMaxPoolPositionsSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, true);\n}\n\nexport function getFragmentShaderMaxPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return getFragmentShaderMaxPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, false);\n}\n\nfunction getFragmentShaderMaxPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, computeMaxPositions: boolean) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions);\n}\n\nexport function maxPoolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as pool_gpu from './pool_gpu';\n\nexport function getFragmentShaderMinPoolSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number) {\n  return pool_gpu.getFragmentShaderPoolCommonSource(\n      xShapeRCD, fSize, stride, pad, 'min', false);\n}\n\nexport function minPool(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol);\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nfunction getFragmentShaderSource(\n    rows: number, columns: number, compOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 outputColumnRow;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      float value = texture2D(matrixA, halfCR / aDimCR).r;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 cr = vec2(c, r);\n          vec2 uv = (cr + halfCR) / aDimCR;\n          float candidate = texture2D(matrixA, uv).r;\n          if (isNaN(candidate)) {\n            gl_FragColor = vec4(candidate, 0, 0, 0);\n            return;\n          }\n          value = ${compOp}(value, candidate);\n        }\n      }\n      gl_FragColor = vec4(value, 0, 0, 0);\n    }`;\n}\n\nexport function getMinFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'min');\n}\n\nexport function getMaxFragmentShaderSource(\n    rows: number, columns: number): string {\n  return getFragmentShaderSource(rows, columns, 'max');\n}\n\nexport function minMax(\n    gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(minMaxProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {MatrixOrientation} from '../math';\nimport {Array2D} from '../ndarray';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as shader_compiler from './shader_compiler';\n\nexport function getFragmentShader(\n    a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation,\n    bOrientation: MatrixOrientation): string {\n  const sharedDim =\n      (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]);\n  const aSnippet =\n      (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow';\n  const bSnippet =\n      (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i';\n\n  const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}];\n  const userCode = `\n    const float sharedDim = ${sharedDim}.0;\n\n    float dotARowBCol(float aRow, float bCol) {\n      float result = 0.0;\n      for (float i = 0.0; i < sharedDim; i += 1.0) {\n        float a = getMatrixA(${aSnippet});\n        float b = getMatrixB(${bSnippet});\n        result += (a * b);\n      }\n      return result;\n    }\n\n    void main() {\n      vec2 resRC = getOutputCoords();\n      setOutput(dotARowBCol(resRC.x, resRC.y));\n    }\n  `;\n  return shader_compiler.makeShader(inputs, out, userCode);\n}\n\nexport function multiplyMatrix(\n    gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture,\n    b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) {\n  gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]);\n  gpgpu.setProgram(multiplyProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.setInputMatrixTexture(b, 'matrixB', 1);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getNegUnaryOp(): string {\n  return 'gl_FragColor = vec4(-value, 0, 0, 0);';\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp());\n}\n\nexport function neg(\n    gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, rows: number,\n    columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result);\n}\n\nexport function uploadNegDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\nimport {GPGPUContext} from './gpgpu_context';\nimport {IS_NAN_SHADER_FUNC} from './webgl_util';\n\nexport function getFragmentShaderPoolCommonSource(\n    xShapeRCD: [number, number, number], fSize: number, stride: number,\n    pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) {\n  if (poolType === 'avg' && computePositions) {\n    throw new Error('Cannot compute positions for average pool.');\n  }\n\n  const depth = xShapeRCD[2];\n\n  const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD);\n\n  let returnValue = 'minMaxValue';\n  if (computePositions) {\n    returnValue = 'minMaxPosition';\n  } else if (poolType === 'avg') {\n    returnValue = 'avgValue';\n  }\n\n  return `\n    precision highp float;\n    uniform sampler2D x;\n    varying vec2 resultUV;\n\n    const vec2 halfCR = vec2(0.5, 0.5);\n    const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]});\n\n    ${IS_NAN_SHADER_FUNC}\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n      float yR = yTexCR.y;\n      float yC = floor(yTexCR.x / ${depth}.0);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) -\n          vec2(${pad}.0, ${pad}.0);\n      float xRCorner = xRCCorner.x;\n      float xCCorner = xRCCorner.y;\n\n      // max/min x(?, ?, d) to get y(yR, yC, d).\n      // ? = to be determined\n      float minMaxValue = 0.0;\n      float minMaxValueFound = 0.0;\n      float minMaxPosition = 0.0;\n      float avgValue = 0.0;\n\n      for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) {\n        float xR = xRCorner + wR;\n        float xTexR = xR;\n\n        for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) {\n          float xC = xCCorner + wC;\n          float xTexC = xC * ${depth}.0 + d;\n\n          vec2 texCR = vec2(xTexC, xTexR);\n\n          // Check if the requested UV is invalid.\n          vec2 uv = (texCR + halfCR) / xShapeCR;\n          bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n          bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n          bool outside = lessThanZero || greaterThanOne;\n          if (outside) {\n            continue;\n          }\n\n          float value = texture2D(x, uv).r;\n          if (isNaN(value)) {\n            gl_FragColor = vec4(value, 0, 0, 0);\n            return;\n          }\n          if (${poolType === 'avg'}) {\n            avgValue += value / ${fSize * fSize}.0;\n          } else {\n            // If a min / max value has already been found, use it. If not, use\n            // the current value.\n            float currentMinMaxValue = mix(\n                value, minMaxValue, minMaxValueFound);\n            if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) {\n              minMaxValue = value;\n              minMaxValueFound = 1.0;\n              if (${computePositions}) {\n                minMaxPosition = wR * ${fSize}.0 + wC;\n              }\n            }\n          }\n        }\n      }\n      gl_FragColor = vec4(${returnValue}, 0, 0, 0);\n    }`;\n}\n\nexport function poolCommon(\n    gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(program);\n  gpgpu.setInputMatrixTexture(x, 'x', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(rows: number, columns: number): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    const vec2 aDimCR = vec2(${columns}.0, ${rows}.0);\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      float sum = 0.0;\n      for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n        for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n          vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n          sum += texture2D(matrixA, uv).r;\n        }\n      }\n      gl_FragColor = vec4(sum, 0, 0, 0);\n    }`;\n}\n\nexport function reduceSum(\n    gpgpu: GPGPUContext, reduceSumProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, 1, 1);\n  gpgpu.setProgram(reduceSumProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadReduceSumDownload(\n    a: Float32Array, rows: number, columns: number): number {\n  const gpgpu = new GPGPUContext();\n  const program: WebGLProgram =\n      gpgpu.createProgram(getFragmentShaderSource(rows, columns));\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0];\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getReluUnaryOp(): string {\n  return `\n    float result = (value < 0.0 ? 0.0 : value);\n    gl_FragColor = vec4(result, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp());\n}\n\nexport function relu(\n    gpgpu: GPGPUContext, reluProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result);\n}\n\nexport function uploadReluDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nimport * as webgl_util from './webgl_util';\n\nexport function getRenderRGBShader(\n    gpgpu: GPGPUContext, destinationWidth: number): WebGLProgram {\n  const fragmentShaderSource = `\n    precision highp float;\n    uniform sampler2D source;\n    varying vec2 resultUV;\n\n    const float destinationWidth = ${destinationWidth}.0;\n    const float a = 1.0;\n\n    void main() {\n      float xr = floor(resultUV.s * destinationWidth) * 3.0;\n      vec3 x = xr + vec3(0, 1, 2);\n\n      float sourceWidth = destinationWidth * 3.0;\n      vec3 u = (x + 0.5) / sourceWidth;\n      float v = 1.0 - resultUV.t;\n\n      float r = texture2D(source, vec2(u[0], v)).r;\n      float g = texture2D(source, vec2(u[1], v)).r;\n      float b = texture2D(source, vec2(u[2], v)).r;\n\n      gl_FragColor = vec4(r, g, b, a);\n    }`;\n\n  return gpgpu.createProgram(fragmentShaderSource);\n}\n\nexport function renderToCanvas(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  webgl_util.bindCanvasToFramebuffer(gpgpu.gl);\n  renderToFramebuffer(gpgpu, renderShader, sourceTex);\n}\n\nexport function renderToFramebuffer(\n    gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) {\n  gpgpu.setProgram(renderShader);\n  gpgpu.setInputMatrixTexture(sourceTex, 'source', 0);\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    uniform vec2 inputDimCR;\n    uniform vec2 resultDimCR;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    void main() {\n      vec2 resultCR = floor(resultUV * resultDimCR);\n      // indexInFlat = row * stride + column, where stride == numOutputColumns\n      float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n      vec2 inputCR = vec2(\n        mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n        floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n      ) + halfCR;\n\n      vec2 inputUV = inputCR / inputDimCR;\n      gl_FragColor = texture2D(matrixA, inputUV);\n    }`;\n}\n\nexport function reshape(\n    gpgpu: GPGPUContext, reshapeProgram: WebGLProgram, a: WebGLTexture,\n    aNumRows: number, aNumCols: number, result: WebGLTexture,\n    resultNumRows: number, resultNumCols: number) {\n  const inputSize = aNumRows * aNumCols;\n  const outputSize = resultNumCols * resultNumRows;\n  util.assert(\n      inputSize === outputSize,\n      `The input size (${inputSize}) and output size (${outputSize}) ` +\n          `must match`);\n\n  gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols);\n  gpgpu.setProgram(reshapeProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n\n  const inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR');\n  gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows);\n\n  const resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR');\n  gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows);\n\n  gpgpu.executeProgram();\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as conv_util from '../conv_util';\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as webgl_util from './webgl_util';\n\nexport function getFragmentShaderSource(\n    inputShapeRCD: [number, number, number],\n    outputDimensionsRowCol: [number, number], alignCorners: boolean): string {\n  const depth = inputShapeRCD[2];\n\n  const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD);\n\n  const effectiveInputShapeRCD = alignCorners ?\n      [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] :\n      inputShapeRCD;\n\n  const effectiveOutputShapeRCD = alignCorners ?\n      [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] :\n      [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth];\n\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    const vec2 inputShapeCR = vec2(${inputShapeRCD[1]}, ${inputShapeRCD[0]});\n    const vec2 inputShapeTexCR = vec2(\n        ${inputTexShapeRC[1]}, ${inputTexShapeRC[0]});\n\n    const vec2 effectiveInputOverOutputRatioCR = vec2(\n        ${effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1]},\n        ${effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0]});\n\n    float sampleInput(float col, float row, float d) {\n      vec2 uv = (vec2(col * ${depth}.0 + d, row) + halfCR) / inputShapeTexCR;\n      return texture2D(matrixA, uv).r;\n    }\n\n    void main() {\n      vec2 yTexCR = floor(gl_FragCoord.xy);\n\n      // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n      vec2 yCR = vec2(floor(yTexCR.x / ${depth}.0), yTexCR.y);\n      float d = mod(yTexCR.x, ${depth}.0);\n\n      // Fractional source index.\n      vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n      // Compute the four integer indices.\n      vec2 sourceFloorCR = floor(sourceFracIndexCR);\n      vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n      float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n      float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n      float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n      float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n      vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n      float top = topLeft + (topRight - topLeft) * fracCR[0];\n      float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n      float newValue = top + (bottom - top) * fracCR[1];\n\n      gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n    }`;\n}\n\nexport function resizeBilinear(\n    gpgpu: GPGPUContext, resizeBilinearProgram: WebGLProgram, a: WebGLTexture,\n    result: WebGLTexture, resultShapeRowCol: [number, number]) {\n  gpgpu.setOutputMatrixTexture(\n      result, resultShapeRowCol[0], resultShapeRowCol[1]);\n  gpgpu.setProgram(resizeBilinearProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport * as util from '../../util';\nimport {NDArray} from '../ndarray';\n\nexport type Input = {\n  name: string; array: NDArray;\n};\n\nexport function makeShaderKey(inputs: NDArray[], output: NDArray): string {\n  const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC());\n  return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC();\n}\n\nexport function makeShader(\n    inputs: Input[], output: NDArray, userCode: string): string {\n  const inputPrefixSnippet =\n      inputs.map(x => `uniform sampler2D ${x.name};`).join('\\n');\n  const inputSamplingSnippet =\n      inputs.map(x => getInputSamplingSnippet(x)).join('\\n');\n  const outTexShape = output.getTextureShapeRC();\n  const outputSamplingSnippet =\n      getOutputSamplingSnippet(output.shape, outTexShape);\n  const source = [\n    SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet,\n    outputSamplingSnippet, userCode\n  ].join('\\n');\n  return source;\n}\n\nfunction getInputSamplingSnippet(input: Input) {\n  const arr = input.array;\n  const shape = arr.shape;\n  const texShape = arr.getTextureShapeRC(shape as [number, number]);\n  switch (shape.length) {\n    case 2:\n      return getSampler2D(input.name, shape as [number, number], texShape);\n    default:\n      throw new Error(`${arr.rank}-D input sampling is not yet supported`);\n  }\n}\n\nfunction getOutputSamplingSnippet(\n    outShape: number[], outTexShape: [number, number]): string {\n  switch (outShape.length) {\n    case 2:\n      return getOutput2DCoords(outShape as [number, number], outTexShape);\n    default:\n      throw new Error(\n          `${outShape.length}-D output sampling is not yet supported`);\n  }\n}\n\nconst SHADER_PREFIX = `\n  precision highp float;\n  varying vec2 resultUV;\n  const vec2 halfCR = vec2(0.5, 0.5);\n\n  void setOutput(float val) {\n    gl_FragColor = vec4(val, 0, 0, 0);\n  }\n`;\n\nconst SAMPLE_2D_SNIPPET = `\n  float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n      float row, float col) {\n    float index = dot(vec2(row, col), vec2(numC, 1.0));\n    float texR = floor(index / texNumC);\n    float texC = mod(index, texNumC);\n    vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n    return texture2D(texture, uv).r;\n  }\n`;\n\nfunction getOutput2DCoords(\n    shape: [number, number], texShape: [number, number]) {\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      vec2 getOutputCoords() {\n        return floor(gl_FragCoord.yx);\n      }\n    `;\n  }\n  return `\n    vec2 getOutputCoords() {\n      vec2 resTexRC = floor(gl_FragCoord.yx);\n      float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0));\n      float r = floor(index / ${shape[1]}.0);\n      float c = mod(index, ${shape[1]}.0);\n      return vec2(r, c);\n    }\n  `;\n}\n\nfunction getSampler2D(\n    texName: string, shape: [number, number], texShape: [number, number]) {\n  const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1);\n  const tR = texShape[0];\n  const tC = texShape[1];\n  if (util.arraysEqual(shape, texShape)) {\n    return `\n      float ${funcName}(float row, float col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0);\n        return texture2D(${texName}, uv).r;\n      }\n    `;\n  }\n  return `\n    float ${funcName}(float row, float col) {\n      return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col);\n    }\n  `;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getSigmoidUnaryOp(): string {\n  return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);';\n}\n\nexport function getSigmoidFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp());\n}\n\nexport function sigmoid(\n    gpgpu: GPGPUContext, sigmoidProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result);\n}\n\nexport function uploadSigmoidDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(\n      a, rows, columns, getSigmoidUnaryOp());\n}","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\nfunction getStepUnaryOp(): string {\n  return `\n    float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n    gl_FragColor = vec4(res, 0, 0, 0);\n  `;\n}\n\nexport function getFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp());\n}\n\nexport function step(\n    gpgpu: GPGPUContext, stepProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result);\n}\n\nexport function uploadStepDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport function getUnpackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns, rows];\n}\n\nexport function getUnpackedArraySizeFromMatrixSize(\n    matrixSize: number, channelsPerTexture: number): number {\n  return matrixSize * channelsPerTexture;\n}\n\nexport function getColorMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [columns * 4, rows];\n}\n\nexport function getMatrixSizeFromUnpackedArraySize(\n    unpackedSize: number, channelsPerTexture: number): number {\n  if (unpackedSize % channelsPerTexture !== 0) {\n    throw new Error(\n        'unpackedSize (' + unpackedSize + ') must be a multiple of ' +\n        channelsPerTexture);\n  }\n  return unpackedSize / channelsPerTexture;\n}\n\nexport function encodeMatrixToUnpackedArray(\n    matrix: Float32Array, unpackedArray: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize =\n      getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture);\n  if (unpackedArray.length < requiredSize) {\n    throw new Error(\n        'unpackedArray length (' + unpackedArray.length +\n        ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < matrix.length; ++src) {\n    unpackedArray[dst] = matrix[src];\n    dst += channelsPerTexture;\n  }\n}\n\nexport function decodeMatrixFromUnpackedArray(\n    unpackedArray: Float32Array, matrix: Float32Array,\n    channelsPerTexture: number) {\n  const requiredSize = getMatrixSizeFromUnpackedArraySize(\n      unpackedArray.length, channelsPerTexture);\n  if (matrix.length < requiredSize) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  let dst = 0;\n  for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) {\n    matrix[dst++] = unpackedArray[src];\n  }\n}\n\nexport function getPackedMatrixTextureShapeWidthHeight(\n    rows: number, columns: number): [number, number] {\n  return [Math.ceil(columns / 2), Math.ceil(rows / 2)];\n}\n\nexport function getPackedRGBAArraySizeFromMatrixShape(\n    rows: number, columns: number): number {\n  const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  return w * h * 4;\n}\n\nexport function encodeMatrixToPackedRGBA(\n    matrix: Float32Array, rows: number, columns: number,\n    packedRGBA: Float32Array) {\n  const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns);\n  if (packedRGBA.length < requiredSize) {\n    throw new Error(\n        'packedRGBA length (' + packedRGBA.length +\n        ') must be >= ' + requiredSize);\n  }\n  /*\n    Unpacked matrix, row-major order in Float32Array[16]:  A B C D\n                                                           E F G H\n                                                           I J K L\n                                                           M N O P\n\n    Packed matrix, 2x2 RGBA32 texture (memory view):       ABEF CDGH IJMN KLOP\n\n    Packed matrix, 2x2 RGBA32 texture (matrix view):       AB|CD\n                                                           EF|GH\n                                                           --+--\n                                                           IJ|KL\n                                                           MN|OP\n   */\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n\n  // loop over full 2x2 blocks\n  {\n    const dstStride = (oddWidth ? 4 : 0);\n    const oneRow = columns;\n    let dst = 0;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      const matrixSrcRow = (blockY * 2 * columns);\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        const matrixSrcCol = blockX * 2;\n        const src = matrixSrcRow + matrixSrcCol;\n        packedRGBA[dst] = matrix[src];\n        packedRGBA[dst + 1] = matrix[src + 1];\n        packedRGBA[dst + 2] = matrix[src + oneRow];\n        packedRGBA[dst + 3] = matrix[src + oneRow + 1];\n        dst += 4;\n      }\n      dst += dstStride;\n    }\n  }\n\n  // loop down final odd column\n  if (oddWidth) {\n    let src = columns - 1;\n    let dst = (textureWidth - 1) * 4;\n    const srcStride = 2 * columns;\n    const dstStride = textureWidth * 4;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      packedRGBA[dst] = matrix[src];\n      packedRGBA[dst + 2] = matrix[src + columns];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (rows - 1) * columns;\n    let dst = (textureHeight - 1) * textureWidth * 4;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      packedRGBA[dst++] = matrix[src++];\n      packedRGBA[dst++] = matrix[src++];\n      dst += 2;\n    }\n  }\n\n  // fill in bottom-right texel\n  if (oddWidth && oddHeight) {\n    packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1];\n  }\n\n  return packedRGBA;\n}\n\nexport function decodeMatrixFromPackedRGBA(\n    packedRGBA: Float32Array, rows: number, columns: number,\n    matrix: Float32Array): Float32Array {\n  const requiredSize = rows * columns;\n  if (requiredSize < matrix.length) {\n    throw new Error(\n        'matrix length (' + matrix.length + ') must be >= ' + requiredSize);\n  }\n  const oddWidth = (columns % 2) === 1;\n  const oddHeight = (rows % 2) === 1;\n  const widthInFullBlocks = Math.floor(columns / 2);\n  const heightInFullBlocks = Math.floor(rows / 2);\n  const [textureWidth, textureHeight] =\n      getPackedMatrixTextureShapeWidthHeight(rows, columns);\n\n  // loop over full 2x2 blocks\n  {\n    const srcStride = oddWidth ? 4 : 0;\n    const dstStride = columns + (oddWidth ? 1 : 0);\n    let src = 0;\n    let dstRow1 = 0;\n    let dstRow2 = columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow1++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n        matrix[dstRow2++] = packedRGBA[src++];\n      }\n      src += srcStride;\n      dstRow1 += dstStride;\n      dstRow2 += dstStride;\n    }\n  }\n\n  // loop down final column\n  if (oddWidth) {\n    let src = (textureWidth - 1) * 4;\n    let dst = columns - 1;\n    const srcStride = textureWidth * 4;\n    const dstStride = 2 * columns;\n    for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) {\n      matrix[dst] = packedRGBA[src];\n      matrix[dst + columns] = packedRGBA[src + 2];\n      src += srcStride;\n      dst += dstStride;\n    }\n  }\n\n  // loop across final row\n  if (oddHeight) {\n    let src = (textureHeight - 1) * textureWidth * 4;\n    let dst = (rows - 1) * columns;\n    for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) {\n      matrix[dst++] = packedRGBA[src++];\n      matrix[dst++] = packedRGBA[src++];\n      src += 2;\n    }\n  }\n\n  // fill in bottom-right cell\n  if (oddWidth && oddHeight) {\n    matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4];\n  }\n\n  return matrix;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport class TextureManager {\n  private numUsedTextures = 0;\n  private numFreeTextures = 0;\n  private freeTextures: {[shape: string]: WebGLTexture[]} = {};\n  private logEnabled = false;\n  private usedTextureCount: {[shape: string]: number} = {};\n\n  constructor(private gpgpu: GPGPUContext) {}\n\n  acquireTexture(shapeRC: [number, number]): WebGLTexture {\n    const shapeKey = getKeyFromTextureShape(shapeRC);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    if (!(shapeKey in this.usedTextureCount)) {\n      this.usedTextureCount[shapeKey] = 0;\n    }\n    this.usedTextureCount[shapeKey]++;\n\n    if (this.freeTextures[shapeKey].length > 0) {\n      this.numFreeTextures--;\n      this.numUsedTextures++;\n      this.log();\n      return this.freeTextures[shapeKey].shift()!;\n    }\n    this.numUsedTextures++;\n    this.log();\n\n    return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]);\n  }\n\n  releaseTexture(texture: WebGLTexture, shape: [number, number]): void {\n    const shapeKey = getKeyFromTextureShape(shape);\n    if (!(shapeKey in this.freeTextures)) {\n      this.freeTextures[shapeKey] = [];\n    }\n    this.freeTextures[shapeKey].push(texture);\n    this.numFreeTextures++;\n    this.numUsedTextures--;\n    this.usedTextureCount[shapeKey]--;\n    this.log();\n  }\n\n  private log() {\n    if (!this.logEnabled) {\n      return;\n    }\n    const total = this.numFreeTextures + this.numUsedTextures;\n    console.log(\n        'Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures,\n        `(${total})`);\n  }\n\n  getNumUsedTextures(): number {\n    return this.numUsedTextures;\n  }\n\n  getNumFreeTextures(): number {\n    return this.numFreeTextures;\n  }\n\n  dispose() {\n    for (const shape in this.freeTextures) {\n      if (this.freeTextures.hasOwnProperty(shape)) {\n        for (let i = 0; i < this.freeTextures[shape].length; i++) {\n          this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]);\n        }\n      }\n    }\n  }\n}\n\nfunction getKeyFromTextureShape(shapeRowsCol: [number, number]): string {\n  return shapeRowsCol[0] + '_' + shapeRowsCol[1];\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\nimport * as unaryop_gpu from './unaryop_gpu';\n\n/**\n * Sine\n */\nfunction getSinUnaryOp(): string {\n  return `\n    gl_FragColor = vec4(sin(value), 0, 0, 0);\n  `;\n}\n\nexport function getSinFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp());\n}\n\nexport function sin(\n    gpgpu: GPGPUContext, sinProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result);\n}\n\nexport function uploadSinDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp());\n}\n\n/**\n * Tanh\n */\nfunction getTanhUnaryOp(): string {\n  return `\n    float e2x = exp(-2.0 * value);\n    gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n  `;\n}\n\nexport function getTanhFragmentShaderSource(): string {\n  return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp());\n}\n\nexport function tanh(\n    gpgpu: GPGPUContext, tanhProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result);\n}\n\nexport function uploadTanhDownload(\n    a: Float32Array, rows: number, columns: number): Float32Array {\n  return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp());\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {GPGPUContext} from './gpgpu_context';\n\nexport function getFragmentShaderSource(resultOp: string): string {\n  return `\n    precision highp float;\n    uniform sampler2D matrixA;\n    varying vec2 resultUV;\n\n    void main() {\n      float value = texture2D(matrixA, resultUV).r;\n      ${resultOp}\n    }`;\n}\n\nexport function unaryOp(\n    gpgpu: GPGPUContext, unaryOpProgram: WebGLProgram, a: WebGLTexture,\n    rows: number, columns: number, result: WebGLTexture) {\n  gpgpu.setOutputMatrixTexture(result, rows, columns);\n  gpgpu.setProgram(unaryOpProgram);\n  gpgpu.setInputMatrixTexture(a, 'matrixA', 0);\n  gpgpu.executeProgram();\n}\n\nexport function uploadUnaryOpDownload(\n    a: Float32Array, rows: number, columns: number,\n    resultOp: string): Float32Array {\n  const gpgpu = new GPGPUContext();\n  const fragmentShaderSrc = getFragmentShaderSource(resultOp);\n  const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSrc);\n  const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns);\n  gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a);\n  unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture);\n  const result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns);\n  gpgpu.deleteMatrixTexture(aTexture);\n  gpgpu.deleteMatrixTexture(resultTexture);\n  gpgpu.deleteProgram(program);\n  gpgpu.dispose();\n  return result;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nlet USE_WEBGL2_WHEN_AVAILABLE = false;\nlet WEBGL2_ENABLED: boolean|undefined = null!;\nlet MAX_TEXTURE_SIZE: number = null!;\n\nimport * as util from '../../util';\n\nexport interface WebGLContextAttributes {\n  alpha?: boolean;\n  antialias?: boolean;\n  premultipliedAlpha?: boolean;\n  preserveDrawingBuffer?: boolean;\n  depth?: boolean;\n  stencil?: boolean;\n  failIfMajorPerformanceCaveat?: boolean;\n}\n\n/** @hidden */\nexport const IS_NAN_SHADER_FUNC = `\nbool isNaN(float val) {\n  return val == val ? false : true;\n}\n`;\n\nexport interface WebGLLoseContextExtension { loseContext(): void; }\n\nexport function createWebGLRenderingContext(attributes: WebGLContextAttributes):\n    WebGLRenderingContext {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return createWebGLRenderingContextFromCanvas(canvas, attributes);\n}\n\n/**\n * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL\n * 2.0 is available.\n */\nexport function preferWebGL1() {\n  USE_WEBGL2_WHEN_AVAILABLE = false;\n  WEBGL2_ENABLED = undefined;\n}\n\n/**\n * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration.\n */\nexport function preferWebGL2() {\n  USE_WEBGL2_WHEN_AVAILABLE = true;\n  WEBGL2_ENABLED = undefined;\n}\n\nexport function isWebGL2Enabled() {\n  if (!USE_WEBGL2_WHEN_AVAILABLE) {\n    return false;\n  }\n\n  if (WEBGL2_ENABLED === undefined) {\n    const tempCanvas = document.createElement('canvas');\n    const gl = tempCanvas.getContext('webgl2');\n    if (gl != null) {\n      WEBGL2_ENABLED = true;\n\n      const loseContextExtension =\n          getExtensionOrThrow(\n              gl as WebGLRenderingContext, 'WEBGL_lose_context') as\n          WebGLLoseContextExtension;\n      loseContextExtension.loseContext();\n    } else {\n      WEBGL2_ENABLED = false;\n    }\n  }\n  return WEBGL2_ENABLED;\n}\n\nexport function createWebGLRenderingContextFromCanvas(\n    canvas: HTMLCanvasElement,\n    attributes: WebGLContextAttributes): WebGLRenderingContext {\n  let gl: WebGLRenderingContext;\n  if (isWebGL2Enabled()) {\n    gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext;\n  } else {\n    gl = (canvas.getContext('webgl', attributes) ||\n          canvas.getContext('experimental-webgl', attributes)) as\n        WebGLRenderingContext;\n  }\n\n  if (gl == null) {\n    throw new Error('This browser does not support WebGL.');\n  }\n  return gl;\n}\n\nexport function callAndCheck<T>(gl: WebGLRenderingContext, func: () => T): T {\n  const returnValue = func();\n  checkWebGLError(gl);\n  return returnValue;\n}\n\nlet webGLDebugErrorCheckingEnabled = false;\n\nexport function enableDebugWebGLErrorChecking(enabled: boolean) {\n  webGLDebugErrorCheckingEnabled = enabled;\n}\n\nexport function checkWebGLError(gl: WebGLRenderingContext) {\n  if (webGLDebugErrorCheckingEnabled) {\n    const error = gl.getError();\n    if (error !== gl.NO_ERROR) {\n      throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error));\n    }\n  }\n}\n\nexport function getWebGLErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.NO_ERROR:\n      return 'NO_ERROR';\n    case gl.INVALID_ENUM:\n      return 'INVALID_ENUM';\n    case gl.INVALID_VALUE:\n      return 'INVALID_VALUE';\n    case gl.INVALID_OPERATION:\n      return 'INVALID_OPERATION';\n    case gl.INVALID_FRAMEBUFFER_OPERATION:\n      return 'INVALID_FRAMEBUFFER_OPERATION';\n    case gl.OUT_OF_MEMORY:\n      return 'OUT_OF_MEMORY';\n    case gl.CONTEXT_LOST_WEBGL:\n      return 'CONTEXT_LOST_WEBGL';\n    default:\n      return 'Unknown error code ' + status;\n  }\n}\n\nexport function getExtensionOrThrow(\n    gl: WebGLRenderingContext, extensionName: string): {} {\n  return throwIfNull<{}>(\n      gl, () => gl.getExtension(extensionName),\n      'Extension \"' + extensionName + '\" not supported on this browser.');\n}\n\nexport function createVertexShader(\n    gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader {\n  const vertexShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.VERTEX_SHADER),\n      'Unable to create vertex WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource));\n  callAndCheck(gl, () => gl.compileShader(vertexShader));\n  if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(vertexShader));\n    throw new Error('Failed to compile vertex shader.');\n  }\n  return vertexShader;\n}\n\nexport function createFragmentShader(\n    gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader {\n  const fragmentShader: WebGLShader = throwIfNull<WebGLShader>(\n      gl, () => gl.createShader(gl.FRAGMENT_SHADER),\n      'Unable to create fragment WebGLShader.');\n  callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource));\n  callAndCheck(gl, () => gl.compileShader(fragmentShader));\n  if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) {\n    console.log(gl.getShaderInfoLog(fragmentShader));\n    throw new Error('Failed to compile fragment shader.');\n  }\n  return fragmentShader;\n}\n\nexport function createProgram(gl: WebGLRenderingContext): WebGLProgram {\n  return throwIfNull<WebGLProgram>(\n      gl, () => gl.createProgram(), 'Unable to create WebGLProgram.');\n}\n\nexport function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.linkProgram(program));\n  if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Failed to link vertex and fragment shaders.');\n  }\n}\n\nexport function validateProgram(\n    gl: WebGLRenderingContext, program: WebGLProgram) {\n  callAndCheck(gl, () => gl.validateProgram(program));\n  if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) {\n    console.log(gl.getProgramInfoLog(program));\n    throw new Error('Shader program validation failed.');\n  }\n}\n\nexport function createStaticVertexBuffer(\n    gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function createStaticIndexBuffer(\n    gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer {\n  const buffer: WebGLBuffer = throwIfNull<WebGLBuffer>(\n      gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer');\n  callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW));\n  return buffer;\n}\n\nexport function queryMaxTextureSize(gl: WebGLRenderingContext): number {\n  if (MAX_TEXTURE_SIZE != null) {\n    return MAX_TEXTURE_SIZE;\n  }\n  MAX_TEXTURE_SIZE =\n      callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE));\n  return MAX_TEXTURE_SIZE;\n}\n\nexport function getChannelsPerTexture(): number {\n  if (isWebGL2Enabled()) {\n    return 1;\n  }\n  return 4;\n}\n\nexport function createTexture(gl: WebGLRenderingContext): WebGLTexture {\n  return throwIfNull<WebGLTexture>(\n      gl, () => gl.createTexture(), 'Unable to create WebGLTexture.');\n}\n\nexport function validateTextureSize(\n    gl: WebGLRenderingContext, width: number, height: number) {\n  const maxTextureSize: number = queryMaxTextureSize(gl);\n  if ((width <= 0) || (height <= 0)) {\n    const requested = '[' + width + 'x' + height + ']';\n    throw new Error('Requested texture size ' + requested + ' is invalid.');\n  }\n  if ((width > maxTextureSize) || (height > maxTextureSize)) {\n    const requested = '[' + width + 'x' + height + ']';\n    const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']';\n    throw new Error(\n        'Requested texture size ' + requested +\n        ' greater than WebGL maximum on this browser / GPU ' + max + '.');\n  }\n}\n\nexport function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer {\n  return throwIfNull<WebGLFramebuffer>(\n      gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.');\n}\n\nexport function bindVertexBufferToProgramAttribute(\n    gl: WebGLRenderingContext, program: WebGLProgram, attribute: string,\n    buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number,\n    itemOffsetInBytes: number) {\n  const loc = gl.getAttribLocation(program, attribute);\n  if (loc === -1) {\n    const error = new Error(\n        'Unable to get attribute \"' + attribute + '\" on WebGLProgram.');\n    // tslint:disable-next-line:no-any\n    (error as any).namedVertexAttributeNotFound = attribute;\n    throw error;\n  }\n  callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer));\n  callAndCheck(\n      gl,\n      () => gl.vertexAttribPointer(\n          loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes,\n          itemOffsetInBytes));\n  callAndCheck(gl, () => gl.enableVertexAttribArray(loc));\n}\n\nexport function bindTextureUnit(\n    gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture));\n}\n\nexport function unbindTextureUnit(\n    gl: WebGLRenderingContext, textureUnit: number) {\n  validateTextureUnit(gl, textureUnit);\n  callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit));\n  callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null));\n}\n\nexport function getProgramUniformLocationOrThrow(\n    gl: WebGLRenderingContext, program: WebGLProgram,\n    uniformName: string): WebGLUniformLocation {\n  return throwIfNull<WebGLUniformLocation>(\n      gl, () => gl.getUniformLocation(program, uniformName),\n      'uniform \"' + uniformName + '\" not present in program.');\n}\n\nexport function bindTextureToProgramUniformSampler(\n    gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture,\n    uniformSamplerName: string, textureUnit: number) {\n  callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit));\n  const samplerLocation =\n      getProgramUniformLocationOrThrow(gl, program, uniformSamplerName);\n  callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit));\n}\n\nexport function bindCanvasToFramebuffer(gl: WebGLRenderingContext) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null));\n  callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height));\n  callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height));\n}\n\nexport function bindColorTextureToFramebuffer(\n    gl: WebGLRenderingContext, texture: WebGLTexture,\n    framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0));\n}\n\nexport function unbindColorTextureFromFramebuffer(\n    gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) {\n  callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer));\n  callAndCheck(\n      gl,\n      () => gl.framebufferTexture2D(\n          gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0));\n}\n\nexport function validateFramebuffer(gl: WebGLRenderingContext) {\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new Error(\n        'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status));\n  }\n}\n\nexport function getFramebufferErrorMessage(\n    gl: WebGLRenderingContext, status: number): string {\n  switch (status) {\n    case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n      return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT';\n    case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n      return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS';\n    case gl.FRAMEBUFFER_UNSUPPORTED:\n      return 'FRAMEBUFFER_UNSUPPORTED';\n    default:\n      return 'unknown error ' + status;\n  }\n}\n\nfunction throwIfNull<T>(\n    gl: WebGLRenderingContext, returnTOrNull: () => T | null,\n    failureMessage: string): T {\n  const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull());\n  if (tOrNull == null) {\n    throw new Error(failureMessage);\n  }\n  return tOrNull as T;\n}\n\nfunction validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) {\n  const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;\n  const glTextureUnit = textureUnit + gl.TEXTURE0;\n  if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) {\n    const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']';\n    throw new Error('textureUnit must be in ' + textureUnitRange + '.');\n  }\n}\n\nexport function getTextureShapeFromLogicalShape(\n    gl: WebGLRenderingContext, logicalShape: number[],\n    preferredTexShape?: [number, number]): [number, number] {\n  const maxTexSize = queryMaxTextureSize(gl);\n  const size = util.sizeFromShape(logicalShape);\n  if (preferredTexShape != null) {\n    const sizePreferred = util.sizeFromShape(preferredTexShape);\n    util.assert(\n        size === sizePreferred,\n        `Size of shape (${size}) must match size of ` +\n            `preferredShape (${sizePreferred})`);\n    if (preferredTexShape[0] <= maxTexSize &&\n        preferredTexShape[1] <= maxTexSize) {\n      return preferredTexShape;\n    }\n  }\n\n  if (logicalShape.length <= 1 && size <= maxTexSize) {\n    return [size, 1];\n  } else if (\n      logicalShape.length === 2 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] <= maxTexSize) {\n    return logicalShape as [number, number];\n  } else if (\n      logicalShape.length === 3 && logicalShape[0] <= maxTexSize &&\n      logicalShape[1] * logicalShape[2] <= maxTexSize) {\n    return [logicalShape[0], logicalShape[1] * logicalShape[2]];\n  } else {\n    return util.sizeToSquarishShape(size);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {AddNode, ArgMaxEqualsNode, ArgMaxNode, Concat3DNode, Convolution2DNode, DivideNode, ExpNode, FusedLinearCombinationNode, Graph, LogNode, MatMulNode, MaxPoolNode, MeanSquaredCostNode, MultiplyNode, Node, ReduceSumNode, ReLUNode, ReshapeNode, SigmoidNode, SoftmaxCrossEntropyCostNode, SoftmaxNode, SplitNode, SquareNode, SubtractNode, TanHNode, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {Add} from './ops/add';\nimport {ArgMax} from './ops/argmax';\nimport {ArgMaxEquals} from './ops/argmaxequals';\nimport {Concat3D} from './ops/concat3d';\nimport {Convolution2D} from './ops/convolution';\nimport {Divide} from './ops/divide';\nimport {ReLU, Sigmoid, Square, TanH} from './ops/element_wise_activation';\nimport {MeanSquaredCost} from './ops/element_wise_cost';\nimport {Exp} from './ops/exp';\nimport {LinearCombination} from './ops/linear_combination';\nimport {Log} from './ops/log';\nimport {MatMul} from './ops/matmul';\nimport {MaxPool} from './ops/max_pool';\nimport {Multiply} from './ops/multiply';\nimport {Operation} from './ops/op';\nimport {ReduceSum} from './ops/reduce_sum';\nimport {Reshape} from './ops/reshape';\nimport {Softmax, SoftmaxCrossEntropyCost} from './ops/softmax';\nimport {Split} from './ops/split';\nimport {Subtract} from './ops/subtract';\n\nexport function emitFromGraphNodes(nodes: Node[]): Operation[] {\n  const ops: Operation[] = [];\n  nodes.forEach(node => Array.prototype.push.apply(ops, emitOpFromNode(node)));\n  return ops;\n}\n\nfunction emitOpFromNode(node: Node): Operation[] {\n  if (node instanceof ReshapeNode) {\n    return [new Reshape(node.inputs[ReshapeNode.X], node.output)];\n  } else if (node instanceof MatMulNode) {\n    const x1 = node.inputs[MatMulNode.X1];\n    const x2 = node.inputs[MatMulNode.X2];\n    return [new MatMul(x1, x2, node.output)];\n  } else if (node instanceof Convolution2DNode) {\n    const w = node.inputs[Convolution2DNode.W];\n    const x = node.inputs[Convolution2DNode.X];\n    const b = node.inputs[Convolution2DNode.B];\n    return [new Convolution2D(\n        w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride,\n        node.zeroPad)];\n  } else if (node instanceof MaxPoolNode) {\n    const x = node.inputs[MaxPoolNode.X];\n    return [new MaxPool(\n        x, node.output, node.fieldSize, node.stride, node.zeroPad)];\n  } else if (node instanceof ExpNode) {\n    return [new Exp(node.inputs[ExpNode.X], node.output)];\n  } else if (node instanceof LogNode) {\n    return [new Log(node.inputs[LogNode.X], node.output)];\n  } else if (node instanceof ReLUNode) {\n    return [new ReLU(node.inputs[ReLUNode.X], node.output)];\n  } else if (node instanceof TanHNode) {\n    return [new TanH(node.inputs[TanHNode.X], node.output)];\n  } else if (node instanceof SigmoidNode) {\n    return [new Sigmoid(node.inputs[SigmoidNode.X], node.output)];\n  } else if (node instanceof SoftmaxCrossEntropyCostNode) {\n    const x = node.inputs[SoftmaxCrossEntropyCostNode.X];\n    const target = node.inputs[SoftmaxCrossEntropyCostNode.TARGET];\n    return [new SoftmaxCrossEntropyCost(x, target, node.output)];\n  } else if (node instanceof SoftmaxNode) {\n    return [new Softmax(node.inputs[SoftmaxNode.X], node.output)];\n  } else if (node instanceof MeanSquaredCostNode) {\n    const label = node.inputs[MeanSquaredCostNode.LABEL];\n    const prediction = node.inputs[MeanSquaredCostNode.PREDICTION];\n    return [new MeanSquaredCost(label, prediction, node.output)];\n  } else if (node instanceof ArgMaxEqualsNode) {\n    return [new ArgMaxEquals(\n        node.inputs[ArgMaxEqualsNode.X1], node.inputs[ArgMaxEqualsNode.X2],\n        node.output)];\n  } else if (node instanceof ArgMaxNode) {\n    return [new ArgMax(node.x, node.output)];\n  } else if (node instanceof FusedLinearCombinationNode) {\n    return [new LinearCombination(\n        node.inputs[FusedLinearCombinationNode.T1],\n        node.inputs[FusedLinearCombinationNode.T2],\n        node.inputs[FusedLinearCombinationNode.C1],\n        node.inputs[FusedLinearCombinationNode.C2], node.output)];\n  } else if (node instanceof Concat3DNode) {\n    return [new Concat3D(\n        node.inputs[Concat3DNode.X1], node.inputs[Concat3DNode.X2], node.axis,\n        node.output)];\n  } else if (node instanceof SquareNode) {\n    return [new Square(node.inputs[SquareNode.X], node.output)];\n  } else if (node instanceof AddNode) {\n    return [new Add(\n        node.inputs[AddNode.T1], node.inputs[AddNode.T2], node.output)];\n  } else if (node instanceof SubtractNode) {\n    return [new Subtract(\n        node.inputs[SubtractNode.T1], node.inputs[SubtractNode.T2],\n        node.output)];\n  } else if (node instanceof MultiplyNode) {\n    return [new Multiply(\n        node.inputs[MultiplyNode.T1], node.inputs[MultiplyNode.T2],\n        node.output)];\n  } else if (node instanceof DivideNode) {\n    return [new Divide(\n        node.inputs[DivideNode.T1], node.inputs[DivideNode.T2], node.output)];\n  } else if (node instanceof SplitNode) {\n    return [new Split(node.inputs[SplitNode.X], node.outputs)];\n  } else if (node instanceof ReduceSumNode) {\n    return [new ReduceSum(node.inputs[ReduceSumNode.X], node.output)];\n  } else if (graph_util.isInputNode(node)) {\n    return [];\n  } else {\n    // tslint:disable-next-line:no-any\n    throw Error('Unsupported node type: ' + (node.constructor as any).name);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Add extends Operation {\n  private dySizeScalar: Scalar;\n\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(x1.shape)) {\n        result = math.scalarPlusArray(x1, x2);\n      } else if (util.isScalarShape(x2.shape)) {\n        result = math.scalarPlusArray(x2, x1);\n      } else {\n        result = math.add(x1, x2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x1Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x1Tensor, dy);\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.x2Tensor, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.x2Tensor, dy);\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMax extends Operation {\n  /**\n   * An ArgMax operation.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMax(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMax backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ArgMaxEquals extends Operation {\n  /**\n   * An ArgMaxEquals operation.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.argMaxEquals(x1, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('ArgMaxEquals backprop unimplemented');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as concat3d_util from '../math/concat3d_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Concat3D extends Operation {\n  /**\n   * A Concat 3D operation.\n   *\n   * Concats two 3D tensors along an axis.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor, private axis: number,\n      private yTensor: Tensor) {\n    super();\n    concat3d_util.assertConcat3DShapesMatch(\n        x1Tensor.shape, x2Tensor.shape, axis);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor) as Array3D;\n    const x2 = inferenceArrays.get(this.x2Tensor) as Array3D;\n\n    math.scope((keep) => {\n      const concatResult = math.concat3D(x1, x2, this.axis);\n      inferenceArrays.set(this.yTensor, keep(concatResult));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    throw new Error('Concat3D backprop not implemented.');\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Convolution2D extends Operation {\n  private zeroPad: number;\n\n  /**\n   * Constructs a convolution op with the specified properties.\n   *\n   * @param inputShape The shape of the input ndarray.\n   * @param fieldSize The size of the filter (rows/cols of sliding window).\n   * @param outputDepth The depth of the output (Number of filters).\n   * @param stride How many pixels to shift the filter by when sliding.\n   *     Defaults to 1.\n   * @param zeroPad How many pixels to pad the input from each side. Defaults to\n   *     a value so that the rows and columns of the output ndarray is\n   *     the same as the input ndarray.\n   * @param weights Optional. The weights of the filters.\n   * @param biases Optional. The bias terms of the filters.\n   */\n  constructor(\n      private wTensor: Tensor, private xTensor: Tensor, private bTensor: Tensor,\n      private yTensor: Tensor, private fieldSize: number,\n      private outputDepth: number, private stride = 1, zeroPad?: number) {\n    super();\n    this.assertWeightsShape(wTensor.shape);\n    this.zeroPad = zeroPad != null ?\n        zeroPad :\n        conv_util.computeDefaultPad(\n            this.xTensor.shape as [number, number, number], this.fieldSize,\n            this.stride);\n    util.assert(\n        util.isInt(this.zeroPad),\n        `The zero padding (${this.zeroPad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const biases = inferenceArrays.get(this.bTensor) as Array1D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.conv2d(x, weights, biases, this.stride, this.zeroPad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const weights = inferenceArrays.get(this.wTensor) as Array4D;\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      const {dw, db, dx} =\n          math.conv2dBackProp(x, dy, weights, this.stride, this.zeroPad);\n      gradientArrays.set(this.wTensor, keep(dw));\n      gradientArrays.set(this.bTensor, keep(db));\n      gradientArrays.set(this.xTensor, keep(dx));\n    });\n  }\n\n  private assertWeightsShape(weightsShape: number[]) {\n    util.assert(\n        weightsShape[0] === this.fieldSize &&\n            weightsShape[1] === this.fieldSize &&\n            weightsShape[2] === this.xTensor.shape[2] &&\n            weightsShape[3] === this.outputDepth,\n        `weights must be of shape [${this.fieldSize},${this.fieldSize},` +\n            `${this.xTensor.shape[2]},${this.outputDepth}] but they are of` +\n            `shape [${weightsShape}]`);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Divide extends Operation {\n  private ones: NDArray;\n\n  /**\n   * Element-wise divide operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarDividedByArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayDividedByScalar(t1, t2);\n      } else {\n        result = math.divide(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    const x1IsScalar = util.isScalarShape(x1.shape);\n    const x2IsScalar = util.isScalarShape(x2.shape);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (x1IsScalar) {\n          const div = math.divide(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(div)));\n\n          div.dispose();\n        } else if (x2IsScalar) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.divide(dy, x2)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        // dx2 = -1 * x1 * x2 ^ -2.\n        const x2Squared = math.elementWiseMul(x2, x2);\n\n        let x1OverX2Squared: NDArray;\n        if (x2IsScalar) {\n          x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared);\n        } else if (x1IsScalar) {\n          x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared);\n        } else {\n          x1OverX2Squared = math.divide(x1, x2Squared);\n        }\n\n        const dx2 = math.neg(x1OverX2Squared);\n        const dyTimesDerivative = math.elementWiseMul(dy, dx2);\n\n        if (x2IsScalar) {\n          gradientArrays.set(this.x2Tensor, keep(math.sum(dyTimesDerivative)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(dyTimesDerivative));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {ActivationFunction, ReLUFunc, SigmoidFunc, SquareFunc, TanHFunc} from '../math/activation_functions';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseActivation extends Operation {\n  constructor(\n      protected xTensor: Tensor, protected yTensor: Tensor,\n      private func: ActivationFunction) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(this.func.output(math, x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    // dE/dx_i = sum_j dE/dy_j * dy_j/dx_i\n    //         = dE/dy_i * dy_i/dx_i\n    const x = inferenceArrays.get(this.xTensor);\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      const dydx = this.func.der(math, x, y);\n      gradientArrays.set(this.xTensor, keep(math.elementWiseMul(dy, dydx)));\n      dydx.dispose();\n    });\n  }\n}\n\n/**\n * @hidden\n */\nexport class ReLU extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new ReLUFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class TanH extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new TanHFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Sigmoid extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SigmoidFunc());\n  }\n}\n\n/**\n * @hidden\n */\nexport class Square extends ElementWiseActivation {\n  constructor(xTensor: Tensor, yTensor: Tensor) {\n    super(xTensor, yTensor, new SquareFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {ElementWiseCostFunction, SquareCostFunc} from '../math/cost_functions';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ElementWiseCost<T extends NDArray> extends Operation {\n  private oneOverNScalar: Scalar;\n\n  constructor(\n      protected x1Tensor: Tensor, protected x2Tensor: Tensor,\n      protected yTensor: Tensor, protected func: ElementWiseCostFunction) {\n    super();\n    this.oneOverNScalar = Scalar.new(1 / util.sizeFromShape(x1Tensor.shape));\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      const elementWiseCost = this.func.cost(math, x1, x2);\n      const sum = math.sum(elementWiseCost);\n      const result = math.scalarTimesArray(this.oneOverNScalar, sum);\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(this.func.der(math, x1, x2)));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(this.func.der(math, x2, x1)));\n      }\n    });\n  }\n\n  dispose() {\n    this.func.dispose();\n    this.oneOverNScalar.dispose();\n  }\n}\n\n/**\n * @hidden\n */\nexport class MeanSquaredCost extends ElementWiseCost<Array1D> {\n  constructor(x1Tensor: Tensor, x2Tensor: Tensor, yTensor: Tensor) {\n    super(x1Tensor, x2Tensor, yTensor, new SquareCostFunc());\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Exp extends Operation {\n  /**\n   * Exponentation operation - e^x.\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.exp(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const y = inferenceArrays.get(this.yTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.elementWiseMul(y, dy)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class LinearCombination extends Operation {\n  /**\n   * A 2-tensor linear combination operation.\n   *\n   * Combines tensors x1 and x2 (of the same shape) with weights c1 & c2;\n   * Computes c1*x1 + c2*x2.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private c1Tensor: Tensor, private c2Tensor: Tensor,\n      private outTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor).asScalar();\n    const c2 = inferenceArrays.get(this.c2Tensor).asScalar();\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const c1 = inferenceArrays.get(this.c1Tensor);\n    const c2 = inferenceArrays.get(this.c2Tensor);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        gradientArrays.set(this.x1Tensor, keep(math.scalarTimesArray(c1, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        gradientArrays.set(this.x2Tensor, keep(math.scalarTimesArray(c2, dy)));\n      }\n\n      if (graph_util.shouldBackProp(this.c1Tensor)) {\n        const dotProduct1 = math.elementWiseMul(x1, dy);\n        gradientArrays.set(this.c1Tensor, keep(math.sum(dotProduct1)));\n      }\n\n      if (graph_util.shouldBackProp(this.c2Tensor)) {\n        const dotProduct2 = math.elementWiseMul(x2, dy);\n        gradientArrays.set(this.c2Tensor, keep(math.sum(dotProduct2)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Log extends Operation {\n  /**\n   * Natural log operation - ln(x)\n   */\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.yTensor, keep(math.log(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.xTensor)) {\n        gradientArrays.set(this.xTensor, keep(math.divide(dy, x)));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {MatrixOrientation, NDArrayMath} from '../math/math';\nimport {Array1D, Array2D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MatMul extends Operation {\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      if (x1.shape.length === 2 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor, keep(math.matMul(x1 as Array2D, x2 as Array2D)));\n      } else if (x1.shape.length === 2 && x2.shape.length === 1) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.matrixTimesVector(x1 as Array2D, x2 as Array1D)));\n      } else if (x1.shape.length === 1 && x2.shape.length === 2) {\n        inferenceArrays.set(\n            this.yTensor,\n            keep(math.vectorTimesMatrix(x1 as Array1D, x2 as Array2D)));\n      }\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    let x1 = inferenceArrays.get(this.x1Tensor);\n    let x2 = inferenceArrays.get(this.x2Tensor);\n    let dy = gradientArrays.get(this.yTensor);\n\n    if (x1.shape.length === 1) {\n      x1 = x1.reshape([1, x1.size]);\n      dy = dy.reshape([1, dy.size]);\n    }\n    if (x2.shape.length === 1) {\n      x2 = x2.reshape([x2.size, 1]);\n      dy = dy.reshape([dy.size, 1]);\n    }\n\n    math.scope((keep) => {\n      // y = x1 * x2\n      // dx1 = dy * x2T\n      // dx2 = x1T * dy\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        const dx1 = math.matMul(\n            dy as Array2D, x2 as Array2D, MatrixOrientation.REGULAR,\n            MatrixOrientation.TRANSPOSED);\n        gradientArrays.set(\n            this.x1Tensor,\n            keep(this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1));\n      }\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        const dx2 = math.matMul(\n            x1 as Array2D, dy as Array2D, MatrixOrientation.TRANSPOSED,\n            MatrixOrientation.REGULAR);\n        gradientArrays.set(\n            this.x2Tensor,\n            keep(this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2));\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as conv_util from '../math/conv_util';\nimport {NDArrayMath} from '../math/math';\nimport {Array2D, Array3D, NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class MaxPool extends Operation {\n  private pad: number;\n\n  constructor(\n      private xTensor: Tensor, private yTensor: Tensor,\n      private fieldSize: number, private stride = 1, pad?: number) {\n    super();\n\n    if (pad != null) {\n      this.pad = pad;\n    } else {\n      this.pad = conv_util.computeDefaultPad(\n          xTensor.shape as [number, number, number], this.fieldSize,\n          this.stride);\n    }\n\n    util.assert(\n        util.isInt(this.pad),\n        `The zero padding (${this.pad}) must be an integer. Change the ` +\n            `stride and/or zero pad parameters`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor,\n          keep(math.maxPool(x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as Array3D;\n    const dy = gradientArrays.get(this.yTensor) as Array3D;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor,\n          keep(math.maxPoolBackprop(\n              dy, x, this.fieldSize, this.stride, this.pad)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class Multiply extends Operation {\n  /**\n   * Element-wise multiply operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private x1Tensor: Tensor, private x2Tensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(x1Tensor.shape) === 1 ||\n            util.sizeFromShape(x2Tensor.shape) === 1 ||\n            util.arraysEqual(x1Tensor.shape, x2Tensor.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.x1Tensor);\n    const t2 = inferenceArrays.get(this.x2Tensor);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarTimesArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.scalarTimesArray(t2, t1);\n      } else {\n        result = math.elementWiseMul(t1, t2);\n      }\n      inferenceArrays.set(this.yTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const x1 = inferenceArrays.get(this.x1Tensor);\n    const x2 = inferenceArrays.get(this.x2Tensor);\n    const dy = gradientArrays.get(this.yTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.x1Tensor)) {\n        if (util.isScalarShape(this.x1Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x2);\n\n          gradientArrays.set(this.x1Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x2.shape)) {\n          gradientArrays.set(\n              this.x1Tensor, keep(math.scalarTimesArray(x2, dy)));\n        } else {\n          gradientArrays.set(this.x1Tensor, keep(math.elementWiseMul(x2, dy)));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.x2Tensor)) {\n        if (util.isScalarShape(this.x2Tensor.shape)) {\n          const mul = math.elementWiseMul(dy, x1);\n\n          gradientArrays.set(this.x2Tensor, keep(math.sum(mul)));\n\n        } else if (util.isScalarShape(x1.shape)) {\n          gradientArrays.set(\n              this.x2Tensor, keep(math.scalarTimesArray(x1, dy)));\n        } else {\n          gradientArrays.set(this.x2Tensor, keep(math.elementWiseMul(x1, dy)));\n        }\n      }\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\n\n/**\n * @hidden\n */\nexport abstract class Operation {\n  abstract feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap):\n      void;\n\n  abstract backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap): void;\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {}\n\n  dispose() {}\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * @hidden\n */\nexport class ReduceSum extends Operation {\n  /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */\n  constructor(private x: Tensor, private outTensor: Tensor) {\n    super();\n    util.assertShapesMatch(outTensor.shape, []);\n  }\n\n  private ones: NDArray;\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.x);\n\n    math.scope((keep) => {\n      inferenceArrays.set(this.outTensor, keep(math.sum(x)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.x)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      const dy = gradientArrays.get(this.outTensor);\n      if (this.ones == null) {\n        const xArray = inferenceArrays.get(this.x);\n        this.ones = NDArray.zerosLike(xArray);\n        this.ones.fill(1);\n      }\n      gradientArrays.set(this.x, keep(math.scalarTimesArray(dy, this.ones)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Reshape<T1 extends NDArray, T2 extends NDArray> extends Operation {\n  constructor(private xTensor: Tensor, private yTensor: Tensor) {\n    super();\n    const xSize = util.sizeFromShape(xTensor.shape);\n    const ySize = util.sizeFromShape(yTensor.shape);\n    util.assert(\n        xSize === ySize,\n        `The input size (${xSize}) and output size (${ySize}) must match`);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const x = inferenceArrays.get(this.xTensor) as T1;\n\n    math.scope((keep) => {\n      inferenceArrays.set(\n          this.yTensor, keep(math.reshape<T1, T2>(x, this.yTensor.shape)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const dy = gradientArrays.get(this.yTensor) as T2;\n\n    math.scope((keep) => {\n      gradientArrays.set(\n          this.xTensor, keep(math.reshape<T2, T1>(dy, this.xTensor.shape)));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport {NDArrayMath} from '../math/math';\nimport {Array1D, NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Softmax extends Operation {\n  constructor(private logitsTensor: Tensor, private output: Tensor) {\n    super();\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    return math.scope((keep) => {\n      inferenceArrays.set(this.output, keep(math.softmax(logits)));\n    });\n  }\n\n  backProp() {\n    throw Error('Softmax backprop is not yet implemented');\n  }\n}\n\nexport class SoftmaxCrossEntropyCost extends Operation {\n  constructor(\n      private logitsTensor: Tensor, private labelTensor: Tensor,\n      private yTensor: Tensor) {\n    super();\n    this.softmaxTensor = new Tensor(logitsTensor.shape);\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const logits = inferenceArrays.get(this.logitsTensor) as Array1D;\n    const label = inferenceArrays.get(this.labelTensor) as Array1D;\n\n    math.scope((keep) => {\n      const softmaxResult = math.softmax(logits);\n\n      inferenceArrays.set(this.softmaxTensor, keep(softmaxResult));\n      inferenceArrays.set(\n          this.yTensor,\n          keep(crossEntropyCost(math, softmaxResult, label, this.epsilon)));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const softmax = inferenceArrays.get(this.softmaxTensor);\n    const label = inferenceArrays.get(this.labelTensor);\n\n    math.scope((keep) => {\n      gradientArrays.set(this.logitsTensor, keep(math.sub(softmax, label)));\n    });\n  }\n\n  disposeTransientArrays(\n      inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {\n    inferenceArrays.disposeArray(this.softmaxTensor);\n  }\n\n  dispose() {\n    this.epsilon.dispose();\n  }\n\n  private softmaxTensor: Tensor;\n  private epsilon = Scalar.new(1e-5);\n}\n\nexport function crossEntropyCost(\n    math: NDArrayMath, y: Array1D, target: Array1D, epsilon: Scalar): Scalar {\n  util.assert(\n      y.size === target.size, 'The output and target must be the same size');\n\n  return math.scope(() => {\n    const yPlusEps = math.scalarPlusArray(epsilon, y);\n    const logOutput = math.log(yPlusEps);\n    const tarLogOutput = math.elementWiseMul(target, logOutput);\n    const costVector = math.neg(tarLogOutput);\n    return math.sum(costVector);\n  });\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\n/**\n * Split ops are used to accumulate backprop derivatives when a node's output\n * tensor is consumed by multiple nodes.\n */\nexport class Split extends Operation {\n  constructor(private input: Tensor, private outputs: Tensor[]) {\n    super();\n    outputs.forEach(output => {\n      util.assertShapesMatch(input.shape, output.shape);\n    });\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const inputArray = inferenceArrays.get(this.input);\n    this.outputs.forEach(output => {\n      inferenceArrays.set(output, inputArray);\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    if (!graph_util.shouldBackProp(this.input)) {\n      return;\n    }\n\n    math.scope((keep) => {\n      let dx = math.add(\n          gradientArrays.get(this.outputs[0]),\n          gradientArrays.get(this.outputs[1]));\n      // Sum across all the derivatives of the consumers of this node.\n      this.outputs.slice(2).forEach(output => {\n        dx = math.add(dx, gradientArrays.get(output));\n      });\n      gradientArrays.set(this.input, keep(dx));\n    });\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from '../graph';\nimport * as graph_util from '../graph_util';\nimport {NDArrayMath} from '../math/math';\nimport {NDArray, Scalar} from '../math/ndarray';\nimport {TensorArrayMap} from '../tensor_array_map';\nimport * as util from '../util';\n\nimport {Operation} from './op';\n\nexport class Subtract extends Operation {\n  private dySizeScalar: Scalar;\n\n  /**\n   * Element-wise subtract operation. Broadcasts if one of the tensors is\n   * scalar.\n   */\n  constructor(\n      private t1: Tensor, private t2: Tensor, private outTensor: Tensor) {\n    super();\n    util.assert(\n        util.sizeFromShape(t1.shape) === 1 ||\n            util.sizeFromShape(t2.shape) === 1 ||\n            util.arraysEqual(t1.shape, t2.shape),\n        'One of t1 or t2 must be a scalar, or t1 and t2 must have ' +\n            'the same shape');\n  }\n\n  feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n\n    math.scope((keep) => {\n      let result: NDArray;\n      if (util.isScalarShape(t1.shape)) {\n        result = math.scalarMinusArray(t1, t2);\n      } else if (util.isScalarShape(t2.shape)) {\n        result = math.arrayMinusScalar(t1, t2);\n      } else {\n        result = math.sub(t1, t2);\n      }\n      inferenceArrays.set(this.outTensor, keep(result));\n    });\n  }\n\n  backProp(\n      math: NDArrayMath, inferenceArrays: TensorArrayMap,\n      gradientArrays: TensorArrayMap) {\n    const t1 = inferenceArrays.get(this.t1);\n    const t2 = inferenceArrays.get(this.t2);\n    const dy = gradientArrays.get(this.outTensor);\n\n    math.scope((keep) => {\n      if (graph_util.shouldBackProp(this.t1)) {\n        if (util.isScalarShape(this.t1.shape)) {\n          const sum = math.sum(dy);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t1, keep(math.divide(sum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t1, keep(dy));\n        }\n      }\n\n      if (graph_util.shouldBackProp(this.t2)) {\n        if (util.isScalarShape(this.t2.shape)) {\n          const sum = math.sum(dy);\n          const negSum = math.neg(sum);\n          if (this.dySizeScalar == null) {\n            this.dySizeScalar = Scalar.new(dy.size);\n          }\n          gradientArrays.set(\n              this.t2, keep(math.divide(negSum, this.dySizeScalar)));\n        } else {\n          gradientArrays.set(this.t2, keep(math.neg(dy)));\n        }\n      }\n    });\n  }\n\n  dispose() {\n    if (this.dySizeScalar != null) {\n      this.dySizeScalar.dispose();\n    }\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {SessionRuntime} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport abstract class Optimizer {\n  protected variableNodes: VariableNode[];\n  protected specifiedVariableNodes: VariableNode[]|null;\n\n  constructor(specifiedVariableList?: Node[]) {\n    if (specifiedVariableList != null) {\n      this.specifiedVariableNodes = specifiedVariableList as VariableNode[];\n    }\n  }\n\n  abstract beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap,\n      gradientArrayMap: TensorArrayMap): void;\n\n  abstract dispose(): void;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\n/**\n * Default comparison function for the priority queue.\n * @param a The first element to compare.\n * @param b The second element to compare.\n * @return \"a > b\" returns > 0. \"a < b\" returns < 0. \"a === b\" returns 0.\n */\nexport function defaultCompare<T>(a: T, b: T): number {\n  if (a === b) {\n    return 0;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * A Comparator is a user-provided function that compares two T instances. The\n * convention for defaultCompare is expected to be followed to maintain the\n * binary min-heap integrity.\n * @param a The first element to compare.\n * @param b The second element to compare.\n */\nexport type Comparator<T> = (a: T, b: T) => number;\n\n/**\n * IndexObserver is a user-provided callback that informs the caller when an\n * element in the priority queue's binary min-heap has been relocated.\n * @param t The element that was relocated.\n * @param newIndex The new location in the binary min-heap of the element.\n */\nexport type IndexObserver<T> = (t: T, newIndex: number) => void;\n\n/**\n * A priority queue, implemented in terms of a binary min-heap. Lower priority\n * numbers are considered higher priority.\n * enqueue, dequeue, and update are all O(log N) with respect to the number of\n * elements in the queue.\n */\nexport class PriorityQueue<T> {\n  private heap: T[] = [];\n\n  /**\n   * @param comparator A function that compares two queue elements.\n   * @param indexObserver An optional callback raised when the priority queue\n   * changes the order of elements in its min-heap. Useful for tracking the\n   * positions of elements that need updating.\n   */\n  constructor(\n      private comparator: Comparator<T>,\n      private indexObserver?: IndexObserver<T>) {}\n\n  /**\n   * Add an element to the priority queue.\n   * @param t The element to enqueue.\n   */\n  enqueue(t: T) {\n    this.heap.push(t);\n    this.onIndexChanged(t, this.heap.length - 1);\n    this.siftUp(this.heap.length - 1);\n  }\n\n  /**\n   * Remove an element from the priority queue.\n   * @return The element in the priority queue with the highest priority\n   * (lowest numeric priority value).\n   */\n  dequeue(): T {\n    if (this.empty()) {\n      throw new Error('dequeue called on empty priority queue.');\n    }\n    const t = this.heap[0];\n    this.swap(0, this.heap.length - 1);\n    this.heap.pop();\n    this.siftDown(0);\n    return t;\n  }\n\n  /**\n   * Updates an element at the specified index. This can be a full element\n   * replacement, or it can be an in-place update. The priority is assumed to be\n   * changed, and the internal storage is updated. This function is only useful\n   * if the storage index of the updated element is known; construct the\n   * PriorityQueue with an IndexObserver to track element locations.\n   * @param newT The new element to replace in the priority queue.\n   * @param index The index to insert the new element into.\n   */\n  update(newT: T, index: number) {\n    /* If the element is at the very end of the heap, no sifting is necessary,\n     * it can be safely removed. */\n    const last = (index === this.heap.length - 1);\n    if (!last) {\n      this.swap(index, this.heap.length - 1);\n    }\n    this.heap.pop();\n    if (!last) {\n      /* The element at 'index' has been removed, and replaced with whatever was\n       * at the end of the heap. Since that element might have come from a\n       * different subtree (and not be a direct descendant of the node at\n       * 'index'), we might need to sift this new value up instead of down. Test\n       * both directions, and sift to wherever the node needs to go.\n       */\n      if (this.siftUpIndex(index) !== -1) {\n        this.siftUp(index);\n      } else if (this.siftDownIndex(index) !== -1) {\n        this.siftDown(index);\n      }\n    }\n    this.enqueue(newT);\n  }\n\n  /**\n   * Predicate for testing whether the PriorityQueue is empty.\n   * @return True if the PriorityQueue is empty, otherwise False.\n   */\n  empty(): boolean {\n    return this.heap.length === 0;\n  }\n\n  private onIndexChanged(t: T, newIndex: number) {\n    if (this.indexObserver) {\n      this.indexObserver(t, newIndex);\n    }\n  }\n\n  /*\n   * Standard zero-indexed binary heap array layout:\n   *   Parent(N) = Floor((N - 1) / 2)\n   *   LeftChild(N) = (N * 2) + 1\n   *   RightChild(N) = (N * 2) + 2\n   */\n\n  private getParentIndex(index: number): number {\n    if (index === 0) {\n      return -1;\n    }\n    return Math.floor((index - 1) / 2);\n  }\n\n  private getLeftChildIndex(index: number): number {\n    const candidate = index * 2 + 1;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private getRightChildIndex(index: number): number {\n    const candidate = index * 2 + 2;\n    return candidate < this.heap.length ? candidate : -1;\n  }\n\n  private siftUpIndex(index: number): number {\n    const parentIndex = this.getParentIndex(index);\n    if (parentIndex === -1) {\n      return -1;\n    }\n    if (this.compare(parentIndex, index) > 0) {\n      return parentIndex;\n    }\n    return -1;\n  }\n\n  private siftUp(index: number) {\n    let siftIndex = this.siftUpIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftUpIndex(index);\n    }\n  }\n\n  private siftDownIndex(index: number): number {\n    if (index >= this.heap.length) {\n      return -1;\n    }\n    let largestChildIndex = index;\n    const leftChildIndex = this.getLeftChildIndex(index);\n    if ((leftChildIndex !== -1) &&\n        (this.compare(leftChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = leftChildIndex;\n    }\n    const rightChildIndex = this.getRightChildIndex(index);\n    if ((rightChildIndex !== -1) &&\n        (this.compare(rightChildIndex, largestChildIndex) < 0)) {\n      largestChildIndex = rightChildIndex;\n    }\n    return (largestChildIndex === index) ? -1 : largestChildIndex;\n  }\n\n  private siftDown(index: number) {\n    let siftIndex = this.siftDownIndex(index);\n    while (siftIndex !== -1) {\n      this.swap(index, siftIndex);\n      index = siftIndex;\n      siftIndex = this.siftDownIndex(index);\n    }\n  }\n\n  private compare(aIndex: number, bIndex: number): number {\n    return this.comparator(this.heap[aIndex], this.heap[bIndex]);\n  }\n\n  private swap(a: number, b: number) {\n    const temp = this.heap[a];\n    this.heap[a] = this.heap[b];\n    this.heap[b] = temp;\n    this.onIndexChanged(this.heap[a], a);\n    this.onIndexChanged(this.heap[b], b);\n  }\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Graph, Node, Tensor} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport * as operation_emitter from './operation_emitter';\nimport {Operation} from './ops/op';\nimport {Optimizer} from './optimizer';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * FeedEntry associates a tensor with user-provided NDArray data.\n */\nexport type FeedEntry = {\n  tensor: Tensor,\n  data: NDArray|InputProvider\n};\n\n/**\n * A FeedDictionary holds a map from tensors to user-provided NDArrays. Feed\n * dictionaries represent the 'entry points' of evaluation, since graph nodes\n * that are replaced by feeds don't need to have their input nodes evaluated.\n * Feed dictionaries usually provide NDArray data for Placeholder nodes, but any\n * node in the graph can be replaced by a feed dictionary entry.\n *\n * @hidden\n */\nexport class FeedDictionary {\n  dict: {[tensorID: number]: FeedEntry} = {};\n\n  /**\n   * Optionally construct a FeedDictionary from an array of entries.\n   * @param feedEntries Optional array of FeedEntry objects.\n   */\n  constructor(feedEntries?: FeedEntry[]) {\n    if (feedEntries) {\n      feedEntries.forEach(entry => this.dict[entry.tensor.id] = entry);\n    }\n  }\n}\n\nexport enum CostReduction {\n  NONE,\n  SUM,\n  MEAN\n}\n\n/**\n * A Session maintains the runtime state required to efficiently evaluate nodes.\n * On their own, graph objects are very lightweight logical topologies; they\n * have no relationship with the GPU. Sessions encapsulate the evaluation of\n * nodes, the management of GPU resources, the caching of evaluation paths, and\n * anything else required to evaluate or train a network.\n */\nexport class Session {\n  /**\n   * @param graph The graph to associate with this Session.\n   * @param math The NDArrayMath interface that this Session should use.\n   */\n  constructor(private graph: Graph, private math: NDArrayMath) {}\n\n  /**\n   * Release all system resources associated with this Session.\n   */\n  dispose() {\n    this.activationArrayMap.dispose();\n    Object.keys(this.runtimeCache).forEach(key => {\n      const runtime = this.runtimeCache[key];\n      if (runtime.operations) {\n        runtime.operations.forEach(op => op.dispose());\n      }\n    });\n    this.runtimeCache = {};\n    if (this.batchSizeScalar != null) {\n      this.batchSizeScalar.dispose();\n    }\n    this.oneScalar.dispose();\n  }\n\n  /**\n   * Evaluate a list of tensors, using the provided feed entries to provide\n   * upstream NDArray input.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param tensors The list of tensors to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed values of the tensors.\n   */\n  evalAll(tensors: Tensor[], feedEntries: FeedEntry[]): NDArray[] {\n    return this.math.scope(() => {\n      const feed = new FeedDictionary(feedEntries);\n      const runtime = this.getOrCreateRuntime(tensors, feed);\n\n      const activations = this.activationArrayMap;\n\n      session_util.disposeAndInitializeOperationOutputs(\n          runtime.nodes, activations);\n      session_util.disposeTransientOperationArrays(\n          runtime.operations, this.activationArrayMap, this.gradientArrayMap);\n\n      session_util.addPersistentArraysToTensorArrayMap(\n          runtime.nodes, activations);\n      session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n          feed, activations, this.math);\n\n      runtime.operations.forEach(op => op.feedForward(this.math, activations));\n\n      const results = tensors.map(x => activations.get(x));\n      tensors.forEach(x => activations.delete(x));\n\n      session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n          feed, activations, this.math);\n\n      return results;\n    });\n  }\n\n  /**\n   * Evaluate a tensor, using the provided feed entries to provide\n   * upstream NDArray input.\n   *\n   * @param tensor The tensor to evaluate.\n   * @param feedEntries List of `FeedEntry` to read when replacing graph\n   * tensors with NDArrays.\n   * @return The computed value of the tensor.\n   */\n  eval(tensor: Tensor, feedEntries: FeedEntry[]): NDArray {\n    return this.evalAll([tensor], feedEntries)[0];\n  }\n\n  /**\n   * Trains a batch.\n   * Returns a reduced cost if the costReduction parameter is set.\n   * When using a `NDArrayMath` object in safe mode this must be used in a\n   * math.scope().\n   * @param costTensor A tensor representing the cost to optimize. Should be a\n   * scalar.\n   * @param feedEntries Feed entries for this train run. Provides inputs.\n   * @param batchSize Batch size for this train loop.\n   * @param optimizer An optimizer to perform weight updates.\n   * @param costReduction An option to allow the user to get a summed, averaged,\n   * or no cost back.\n   * @return The reduced cost, if cost reduction is not NONE. The user is\n   * responsible for disposing the cost NDArray between train loops.\n   */\n  train(\n      costTensor: Tensor, feedEntries: FeedEntry[], batchSize: number,\n      optimizer: Optimizer, costReduction = CostReduction.NONE): Scalar {\n    util.assert(\n        util.isScalarShape(costTensor.shape),\n        'Cost tensor for training must be a scalar value.');\n\n    if (this.prevBatchSize !== batchSize) {\n      this.prevBatchSize = batchSize;\n      this.batchSizeScalar = Scalar.new(batchSize);\n    }\n\n    const feed = new FeedDictionary(feedEntries);\n    session_util.throwIfFeedDictionaryContainsNDArrays(feed);\n\n    const runtime = this.getOrCreateRuntime([costTensor], feed);\n    const inferenceOperations = runtime.operations;\n    const backPropOperations = runtime.operations.slice().reverse();\n    const activations = this.activationArrayMap;\n    const gradients = this.gradientArrayMap;\n    gradients.set(costTensor, this.oneScalar);\n\n    session_util.addPersistentArraysToTensorArrayMap(\n        runtime.nodes, activations);\n\n    optimizer.beforeBatch(\n        this.math, batchSize, runtime, activations, gradients);\n\n    return this.math.scope((keep, track) => {\n      let cost = track(Scalar.new(0));\n\n      for (let i = 0; i < batchSize; ++i) {\n        session_util.disposeAndInitializeOperationOutputs(\n            runtime.nodes, activations);\n        session_util.disposeAndInitializeOperationInputGradients(\n            runtime.nodes, gradients);\n        session_util.disposeTransientOperationArrays(\n            runtime.operations, activations, gradients);\n\n        session_util.loadInputsFromFeedDictionaryToTensorArrayMap(\n            feed, activations, this.math);\n\n        inferenceOperations.forEach(\n            op => op.feedForward(this.math, activations));\n        backPropOperations.forEach(\n            op => op.backProp(this.math, activations, gradients));\n\n        optimizer.afterExample(this.math, runtime, activations, gradients);\n\n        session_util.releaseFeedDictionaryInputsFromTensorArrayMap(\n            feed, activations, this.math);\n\n        cost = this.updateCostForExample(\n            cost, activations.get(costTensor), costReduction);\n      }\n\n      optimizer.afterBatch(\n          this.math, batchSize, runtime, activations, gradients);\n\n      return this.updateCostForBatch(cost, costReduction);\n    });\n  }\n\n  private updateCostForExample(\n      totalCost: Scalar, currCost: Scalar,\n      costReduction: CostReduction): Scalar {\n    if (costReduction === CostReduction.MEAN ||\n        costReduction === CostReduction.SUM) {\n      return this.math.add(totalCost, currCost);\n    }\n    return totalCost;\n  }\n\n  private updateCostForBatch(totalCost: Scalar, costReduction: CostReduction):\n      Scalar {\n    if (costReduction === CostReduction.MEAN) {\n      return this.math.divide(totalCost, this.batchSizeScalar);\n    }\n    return totalCost;\n  }\n\n  private getOrCreateRuntime(tensors: Tensor[], feed: FeedDictionary):\n      SessionRuntime {\n    const key = this.makeRuntimeCacheKey(tensors, feed);\n    let runtime = this.runtimeCache[key];\n    if (runtime === undefined) {\n      let nodes =\n          session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed);\n      // In inference mode split nodes are not needed, but their cost is\n      // negligible, and always adding them in allows for caching of 1 runtime\n      // for both train/eval.\n      nodes = session_util.addSplitNodes(nodes);\n      session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes);\n      session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes);\n      const operations = operation_emitter.emitFromGraphNodes(nodes);\n      runtime = {nodes, operations};\n      this.runtimeCache[key] = runtime;\n    }\n\n    return runtime;\n  }\n\n  private makeRuntimeCacheKey(tensors: Tensor[], feed: FeedDictionary): string {\n    return tensors.map(x => x.id).sort().join('_') + '__' +\n        Object.keys(feed.dict).sort().join('_');\n  }\n\n  /** Maps each output tensor of the graph to its activation value. */\n  activationArrayMap = new TensorArrayMap();\n  /** Maps each tensor of the graph to its derivative wrt the cost function. */\n  gradientArrayMap = new TensorArrayMap();\n  private runtimeCache: {[key: string]: SessionRuntime} = {};\n  /** Batch size of the previous train() call. */\n  private prevBatchSize: number;\n  private batchSizeScalar: Scalar;\n  private oneScalar = Scalar.new(1);\n}\n\n/** @hidden */\nexport type SessionRuntime = {\n  nodes: Node[]; operations: Operation[];\n};\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {ConstantNode, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph';\nimport * as graph_util from './graph_util';\nimport {InputProvider} from './input_provider';\nimport {NDArrayMath} from './math/math';\nimport {NDArray} from './math/ndarray';\nimport {Operation} from './ops/op';\nimport {FeedDictionary} from './session';\nimport {TensorArrayMap} from './tensor_array_map';\nimport * as util from './util';\n\n/**\n * Creates an array of graph nodes that stop traversal, based on the contents\n * of the provided FeedDictionary. This is a simple 1:1 extraction of nodes from\n * the FeedDictionary.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to scan for termination nodes.\n * @return an array of Nodes which halt traversal when visited.\n */\nexport function getTerminatingNodesFromFeedDictionary(\n    feedDictionary: FeedDictionary): Node[] {\n  return Object.keys(feedDictionary.dict)\n      .map(tensorID => feedDictionary.dict[+tensorID].tensor.node);\n}\n\n/**\n * Given a tensor and a feed dictionary, computes the set of nodes that need to\n * be evaluated to perform inference.\n *\n * @hidden\n * @param evalTensors The list of tensors to eventually be evaluated.\n * @param feedDictionary The populated feed dictionary.\n * @return The set of nodes to evaluate, in evaluation order.\n */\nexport function getOrderedEvaluationSetFromEvalTensor(\n    evalTensors: Tensor[], feedDictionary: FeedDictionary): Node[] {\n  const terminatingNodes =\n      getTerminatingNodesFromFeedDictionary(feedDictionary);\n  const evalNodes = evalTensors.map(x => x.node);\n  const unorderedEvaluationSet =\n      graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes);\n  const orderedEvaluationSet =\n      graph_util.getOrderedEvaluationSet(unorderedEvaluationSet);\n  return orderedEvaluationSet;\n}\n\n/**\n * Traverses the provided node array and adds all persistent node NDArrays to\n * the provided TensorArrayMap.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n * @param tensorArrayMap The map that receives the NDArrays from persistent\n * nodes.\n */\nexport function addPersistentArraysToTensorArrayMap(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode || node instanceof ConstantNode) {\n      tensorArrayMap.set(node.output, node.data);\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function getVariableNodesFromEvaluationSet(evaluationSet: Node[]):\n    VariableNode[] {\n  const nodes: VariableNode[] = [];\n  evaluationSet.forEach(node => {\n    if (node instanceof VariableNode) {\n      nodes.push(node);\n    }\n  });\n  return nodes;\n}\n\n/**\n * @hidden\n */\nexport function throwIfFeedDictionaryContainsNDArrays(\n    feedDictionary: FeedDictionary) {\n  Object.keys(feedDictionary.dict).forEach(tensorID => {\n    if (feedDictionary.dict[+tensorID].data instanceof NDArray) {\n      throw new Error(\n          'training requires FeedDictionary entries to be InputProviders' +\n          'and not NDArrays.');\n    }\n  });\n}\n\n/**\n * @hidden\n */\nexport function loadInputsFromFeedDictionaryToTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    let data: NDArray;\n    if (feedEntry.data instanceof NDArray) {\n      data = feedEntry.data as NDArray;\n    } else {\n      const provider = feedEntry.data as InputProvider;\n      data = provider.getNextCopy(math);\n    }\n\n    util.assert(\n        util.arraysEqual(feedEntry.tensor.shape, data.shape),\n        `Error loading FeedEntry: feeding NDArray of shape ${data.shape} ` +\n            `does not match Tensor (id: ${feedEntry.tensor.id}) shape: ` +\n            `${feedEntry.tensor.shape}.`);\n    activations.set(feedEntry.tensor, data);\n  });\n}\n\n\n/**\n * @hidden\n */\nexport function releaseFeedDictionaryInputsFromTensorArrayMap(\n    batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) {\n  Object.keys(batchFeed.dict).forEach(tensorID => {\n    const feedEntry = batchFeed.dict[+tensorID];\n\n    if (!(feedEntry.data instanceof NDArray)) {\n      const provider = feedEntry.data as InputProvider;\n\n      const feedEntryArray = activations.get(feedEntry.tensor);\n      provider.disposeCopy(math, feedEntryArray);\n    }\n\n    activations.delete(feedEntry.tensor);\n  });\n}\n\n/**\n * Removes all nodes from the provided Node array whose output tensors exist in\n * the provided feed dictionary. After calling this, the Node array should\n * contain zero Placeholder nodes, or the user has failed to provide a feed for\n * a Placeholder node.\n *\n * @hidden\n * @param feedDictionary The FeedDictionary to process.\n * @param evaluationSet The array of nodes to remove input nodes from.\n */\nexport function removeFeedDictionaryNodesFromEvaluationSet(\n    feedDictionary: FeedDictionary, evaluationSet: Node[]) {\n  let i = 0;\n  while (i < evaluationSet.length) {\n    const node = evaluationSet[i];\n    if (feedDictionary.dict[node.output.id] != null) {\n      evaluationSet.splice(i, 1);\n    } else {\n      ++i;\n    }\n  }\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from operation outputs and sets\n * the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param tensorArrayMap The map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationOutputs(\n    evaluationSet: Node[], tensorArrayMap: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    if (!graph_util.isInputNode(node)) {\n      if (!graph_util.isPassthroughNode(node, tensorArrayMap)) {\n        tensorArrayMap.disposeArray(node.output);\n      }\n      tensorArrayMap.set(node.output, null);\n    }\n  });\n}\n\n/**\n * Disposes any NDArrays on the tensorArrayMap from derivatives of operation\n * inputs and sets the value to null.\n *\n * @hidden\n * @param evaluationSet The set of nodes to be evaluated.\n * @param gradients The gradient map to dispose and initialize.\n */\nexport function disposeAndInitializeOperationInputGradients(\n    evaluationSet: Node[], gradients: TensorArrayMap) {\n  evaluationSet.forEach(node => {\n    Object.keys(node.inputs).forEach(inputName => {\n      const input = node.inputs[inputName];\n      if (gradients.get(input, true) !== gradients.get(node.output, true)) {\n        gradients.disposeArray(input);\n      }\n      gradients.set(input, null);\n    });\n  });\n}\n\n\n/**\n * Calls underlying operation disposeTransientArrays methods which clean up any\n * NDArrays which operations may have created during a run.\n *\n * @hidden\n * @param operationNodes The array of Nodes to traverse.\n * @param outputTensor The tensor being evaluated.\n * @param map The TensorArrayMap to operate on.\n */\nexport function disposeTransientOperationArrays(\n    operations: Operation[], activations: TensorArrayMap,\n    gradients: TensorArrayMap) {\n  operations.forEach(op => op.disposeTransientArrays(activations, gradients));\n}\n\n/**\n * Iterates the provided Node array and throws an exception if there are any\n * Placeholder nodes present. Call after the evaluation set has been pruned with\n * the accompanying FeedDictionary to ensure that all inputs have been resolved.\n *\n * @hidden\n * @param evaluationSet The array of nodes to scan.\n */\nexport function throwErrorIfEvaluationSetContainsPlaceholderNodes(\n    evaluationSet: Node[]) {\n  evaluationSet.forEach(node => {\n    if (node instanceof PlaceholderNode) {\n      const shape = '[' + node.output.shape.join(', ') + ']';\n      throw new Error(\n          'Placeholder node \"' + node.name + '\" ' + shape +\n          ' not present in feed dictionary.');\n    }\n  });\n}\n\n/**\n * Injects splits nodes after every node that has multiple consumers.\n *\n * @hidden\n * @param nodes The node list in evaluation order.\n * @return The node list with split nodes injected.\n */\nexport function addSplitNodes(nodes: Node[]): Node[] {\n  const nodeIdToNumConsumers: number[] = [];\n  const nodeIdToSplitNode: {[nodeId: number]: SplitNode} = {};\n\n  // Find nodes that have multiple consumers.\n  nodes.forEach(node => {\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const input = inputTensor.node;\n      if (nodeIdToNumConsumers[input.id] == null) {\n        nodeIdToNumConsumers[input.id] = 0;\n      }\n      nodeIdToNumConsumers[input.id]++;\n      if (nodeIdToNumConsumers[input.id] > 1 &&\n          nodeIdToSplitNode[input.id] == null) {\n        nodeIdToSplitNode[input.id] = new SplitNode(input.graph, inputTensor);\n      }\n    });\n  });\n\n  // Inject a split node after each node that has multiple consumers and\n  // rewire the inputs of the consumers to consume the output tensors of the\n  // split node instead of the original node. Each consumer consumes a\n  // different output tensor so that derivatives are not overwritten.\n  // x-->y  becomes x-->s-->y   where y consumes the 1st output tensor of s\n  // |-->z              |-->z     and z consumes the 2nd output tensor of s\n  const newNodes: Node[] = [];\n  nodes.forEach(node => {\n    newNodes.push(node);\n    if (node.id in nodeIdToSplitNode) {\n      const splitNode = nodeIdToSplitNode[node.id];\n      newNodes.push(splitNode);\n    }\n    const keys = Object.keys(node.inputs);\n    keys.forEach(key => {\n      const inputTensor = node.inputs[key];\n      const inputId = inputTensor.node.id;\n      if (inputId in nodeIdToSplitNode) {\n        node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor();\n      }\n    });\n  });\n  return newNodes;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Node, Tensor, VariableNode} from './graph';\nimport {NDArrayMath} from './math/math';\nimport {NDArray, Scalar} from './math/ndarray';\nimport {Optimizer} from './optimizer';\nimport {SessionRuntime} from './session';\nimport * as session_util from './session_util';\nimport {TensorArrayMap} from './tensor_array_map';\n\nexport class SGDOptimizer extends Optimizer {\n  constructor(private learningRate: number, specifiedVariableList?: Node[]) {\n    super(specifiedVariableList);\n  }\n\n  beforeBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    this.variableNodes = this.specifiedVariableNodes == null ?\n        session_util.getVariableNodesFromEvaluationSet(runtime.nodes) :\n        this.specifiedVariableNodes;\n    if (batchSize !== this.prevBatchSize) {\n      this.prevBatchSize = batchSize;\n      this.c = Scalar.new(-this.learningRate / batchSize);\n    }\n    this.variableNodes.forEach(\n        node => this.variableGradients.set(\n            node.output, NDArray.zeros(node.output.shape)));\n  }\n\n  afterExample(\n      math: NDArrayMath, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const gradient = gradientArrayMap.get(node.output);\n        const accumulatedGradient = this.variableGradients.get(node.output);\n        this.variableGradients.set(\n            node.output, keep(math.add(gradient, accumulatedGradient)));\n        accumulatedGradient.dispose();\n      });\n    });\n  }\n\n  afterBatch(\n      math: NDArrayMath, batchSize: number, runtime: SessionRuntime,\n      activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) {\n    math.scope((keep) => {\n      this.variableNodes!.forEach(node => {\n        const oldVariable = activationArrayMap.get(node.output);\n        const gradient = this.variableGradients.get(node.output);\n        const variable =\n            math.scaledArrayAdd(this.c!, gradient, this.one!, oldVariable);\n        activationArrayMap.set(node.output, keep(variable));\n        node.data = variable;\n\n        oldVariable.dispose();\n      });\n    });\n\n    this.variableGradients.dispose();\n    this.variableGradients = new TensorArrayMap();\n  }\n\n  dispose() {\n    if (this.c != null) {\n      this.c.dispose();\n    }\n    this.one.dispose();\n  }\n\n  setLearningRate(learningRate: number) {\n    this.learningRate = learningRate;\n  }\n\n  private variableGradients = new TensorArrayMap();\n  private prevBatchSize: number;\n  private one = Scalar.new(1);\n  private c: Scalar;\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nimport {Tensor} from './graph';\nimport {NDArray} from './math/ndarray';\n\n/**\n * TensorArrayMap is an internal map from Tensor IDs to NDArrays. Since NDArrays\n * can be backed by WebGL textures, the TensorArrayMap is only used inside of a\n * Session.\n */\nexport class TensorArrayMap {\n  /**\n   * Add or replace an entry in the map.\n   * @param tensor The tensor key.\n   * @param array The NDArray value, can be null.\n   */\n  set(tensor: Tensor, array: NDArray|null) {\n    this.dict[tensor.id] = array;\n  }\n\n  /**\n   * Returns the NDArray associated with the provided tensor. Will throw an\n   * exception if the tensor is not a key in the map, or if the associated\n   * NDArray is null.\n   * @param tensor The tensor key.\n   * @param skipChecks False by default. If true will skip all checks.\n   * @return The NDArray associated with the tensor.\n   */\n  get(tensor: Tensor, skipChecks = false): NDArray {\n    if (!skipChecks && this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    const nda = this.dict[tensor.id];\n    if (!skipChecks && nda === null) {\n      throw new Error('tensor ' + tensor.id + ' has null array.');\n    }\n    return nda!;\n  }\n\n  /**\n   * Removes a tensor/NDArray pair from the map.\n   * @param tensor The tensor key.\n   */\n  delete(tensor: Tensor) {\n    delete this.dict[tensor.id];\n  }\n\n  disposeArray(tensor: Tensor) {\n    if (this.dict[tensor.id] === undefined) {\n      return;\n    }\n    const nda = this.dict[tensor.id];\n    if (nda === null) {\n      return;\n    }\n    nda.dispose();\n    this.dict[tensor.id] = null;\n  }\n\n  /**\n   * @return The number of tensor/NDArray pairs in the map.\n   */\n  size(): number {\n    return Object.keys(this.dict).length;\n  }\n\n  /**\n   * Iterate over all contained NDArray values and dispose them.\n   */\n  dispose() {\n    Object.keys(this.dict).forEach(tensorID => {\n      const nda = this.dict[+tensorID];\n      if (nda) {\n        nda.dispose();\n      }\n    });\n    this.dict = {};\n  }\n\n  /**\n   * Tests to see if a tensor has a null associated with it. Throws\n   * if the tensor is not a key in the map.\n   * @param tensor The tensor key.\n   * @return True if the associated NDArray is null, else False.\n   */\n  hasNullArray(tensor: Tensor): boolean {\n    if (this.dict[tensor.id] === undefined) {\n      throw new Error('tensor ' + tensor.id + ' not in array map.');\n    }\n    return this.dict[tensor.id] === null;\n  }\n\n  private dict: {[tensorID: number]: NDArray | null} = {};\n}\n","/* Copyright 2017 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n\nexport type Vector = number[] | Float64Array | Float32Array | Int32Array |\n    Int8Array | Int16Array;\n\n/** Shuffles the array using Fisher-Yates algorithm. */\n// tslint:disable-next-line:no-any\nexport function shuffle(array: any[]|Uint32Array|Int32Array|\n                        Float32Array): void {\n  let counter = array.length;\n  let temp = 0;\n  let index = 0;\n  // While there are elements in the array\n  while (counter > 0) {\n    // Pick a random index\n    index = (Math.random() * counter) | 0;\n    // Decrease counter by 1\n    counter--;\n    // And swap the last element with it\n    temp = array[counter];\n    array[counter] = array[index];\n    array[index] = temp;\n  }\n}\n\n/** Clamps a value to a specified range. */\nexport function clamp(min: number, x: number, max: number): number {\n  return Math.max(min, Math.min(x, max));\n}\n\n/** Returns a sample from a uniform [a, b] distribution. */\nexport function randUniform(a: number, b: number) {\n  return Math.random() * (b - a) + a;\n}\n\n/**\n * Samples from a gaussian distribution.\n *\n * @param mean The mean. Default is 0.\n * @param stdDev The standard deviation. Default is 1.\n */\nexport function randGauss(mean = 0, stdDev = 1, truncated = false): number {\n  let v1: number, v2: number, s: number;\n  do {\n    v1 = 2 * Math.random() - 1;\n    v2 = 2 * Math.random() - 1;\n    s = v1 * v1 + v2 * v2;\n  } while (s > 1);\n\n  const result = Math.sqrt(-2 * Math.log(s) / s) * v1;\n  if (truncated && result > 2) {\n    return randGauss(mean, stdDev, true);\n  }\n  return mean + stdDev * result;\n}\n\n/** Returns squared eucledian distance between two vectors. */\nexport function distSquared(a: Vector, b: Vector): number {\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    const diff = a[i] - b[i];\n    result += diff * diff;\n  }\n  return result;\n}\n\nexport function assert(expr: boolean, msg: string) {\n  if (!expr) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertShapesMatch(\n    shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void {\n  assert(\n      arraysEqual(shapeA, shapeB),\n      errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`);\n}\n\n// tslint:disable-next-line:no-any\nexport function flatten(arr: any[], ret?: number[]): number[] {\n  ret = (ret === undefined ? [] : ret);\n  for (let i = 0; i < arr.length; ++i) {\n    if (Array.isArray(arr[i])) {\n      flatten(arr[i], ret);\n    } else {\n      ret.push(arr[i]);\n    }\n  }\n  return ret;\n}\n\nexport type ArrayData = number|number[]|number[][]|number[][][]|number[][][][];\n\nexport function inferShape(arr: ArrayData): number[] {\n  const shape: number[] = [];\n  while (arr instanceof Array) {\n    shape.push(arr.length);\n    arr = arr[0];\n  }\n  return shape;\n}\n\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\n\nexport function isScalarShape(shape: number[]): boolean {\n  return shape.length === 0;\n}\n\n// tslint:disable-next-line:no-any\nexport function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) {\n  if (n1.length !== n2.length) {\n    return false;\n  }\n  for (let i = 0; i < n1.length; i++) {\n    if (n1[i] !== n2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\n\nexport function tanh(x: number): number {\n  // tslint:disable-next-line:no-any\n  if ((Math as any).tanh != null) {\n    // tslint:disable-next-line:no-any\n    return (Math as any).tanh(x);\n  }\n  if (x === Infinity) {\n    return 1;\n  } else if (x === -Infinity) {\n    return -1;\n  } else {\n    const e2x = Math.exp(2 * x);\n    return (e2x - 1) / (e2x + 1);\n  }\n}\n\nexport function sizeToSquarishShape(size: number): [number, number] {\n  for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) {\n    if (size % a === 0) {\n      return [a, size / a];\n    }\n  }\n  return [1, size];\n}\n\nexport function createShuffledIndices(n: number): Uint32Array {\n  const shuffledIndices = new Uint32Array(n);\n  for (let i = 0; i < n; ++i) {\n    shuffledIndices[i] = i;\n  }\n  shuffle(shuffledIndices);\n  return shuffledIndices;\n}\n"]} diff --git a/demos/nn-art/cppn.ts b/demos/nn-art/cppn.ts new file mode 100644 index 0000000000..5f25b2263e --- /dev/null +++ b/demos/nn-art/cppn.ts @@ -0,0 +1,186 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Array1D, Array2D, gpgpu_util, GPGPUContext, NDArrayMathGPU, Scalar, webgl_util} from '../deeplearnjs'; + +import * as nn_art_util from './nn_art_util'; + +const MAX_LAYERS = 10; + +export type ColorMode = 'rgb'|'rgba'|'hsv'|'hsva'|'yuv'|'yuva'|'bw'; +const colorModeOutputDimensions: {[colorMode in ColorMode]: number} = { + 'rgb': 3, + 'rgba': 4, + 'hsv': 3, + 'hsva': 4, + 'yuv': 3, + 'yuva': 4, + 'bw': 1 +}; + +export type ActivationFunction = 'tanh'|'sin'|'relu'|'step'; +const activationFunctionMap: { + [activationFunction in ActivationFunction]: + (math: NDArrayMathGPU, ndarray: Array2D) => Array2D +} = { + 'tanh': (math: NDArrayMathGPU, ndarray: Array2D) => math.tanh(ndarray), + 'sin': (math: NDArrayMathGPU, ndarray: Array2D) => math.sin(ndarray), + 'relu': (math: NDArrayMathGPU, ndarray: Array2D) => math.relu(ndarray), + 'step': (math: NDArrayMathGPU, ndarray: Array2D) => math.step(ndarray) +}; + +const NUM_IMAGE_SPACE_VARIABLES = 3; // x, y, r +const NUM_LATENT_VARIABLES = 2; + +export class CPPN { + private math: NDArrayMathGPU; + private gl: WebGLRenderingContext; + private gpgpu: GPGPUContext; + private renderShader: WebGLProgram; + private addLatentVariablesShader: WebGLProgram; + + private inputAtlas: Array2D; + private weights: Array2D[] = []; + + private z1Counter = 0; + private z2Counter = 0; + private z1Scale: number; + private z2Scale: number; + private numLayers: number; + + private colorModeNames: ColorMode[] = + ['rgb', 'rgba', 'hsv', 'hsva', 'yuv', 'yuva', 'bw']; + private activationFunctionNames: ActivationFunction[] = + ['tanh', 'sin', 'relu', 'step']; + + private selectedColorModeName: ColorMode; + private selectedActivationFunctionName: ActivationFunction; + + private isInferring = false; + + constructor(private inferenceCanvas: HTMLCanvasElement) { + this.gl = gpgpu_util.createWebGLContext(this.inferenceCanvas); + this.gpgpu = new GPGPUContext(this.gl); + this.math = new NDArrayMathGPU(this.gpgpu); + + const maxTextureSize = webgl_util.queryMaxTextureSize(this.gl); + const canvasSize = Math.floor(Math.sqrt(maxTextureSize)); + this.inferenceCanvas.width = canvasSize; + this.inferenceCanvas.height = canvasSize; + + this.renderShader = nn_art_util.getRenderShader(this.gpgpu, canvasSize); + this.addLatentVariablesShader = nn_art_util.getAddLatentVariablesShader( + this.gpgpu, NUM_IMAGE_SPACE_VARIABLES); + this.inputAtlas = nn_art_util.createInputAtlas( + canvasSize, NUM_IMAGE_SPACE_VARIABLES, NUM_LATENT_VARIABLES); + } + + generateWeights(neuronsPerLayer: number, weightsStdev: number) { + for (let i = 0; i < this.weights.length; i++) { + this.weights[i].dispose(); + } + this.weights = []; + + this.weights.push(Array2D.randTruncatedNormal( + [neuronsPerLayer, NUM_IMAGE_SPACE_VARIABLES + NUM_LATENT_VARIABLES], 0, + weightsStdev)); + for (let i = 0; i < MAX_LAYERS; i++) { + this.weights.push(Array2D.randTruncatedNormal( + [neuronsPerLayer, neuronsPerLayer], 0, weightsStdev)); + } + this.weights.push(Array2D.randTruncatedNormal( + [4 /** max output channels */, neuronsPerLayer], 0, weightsStdev)); + } + + setColorMode(colorMode: ColorMode) { + this.selectedColorModeName = colorMode; + } + + setActivationFunction(activationFunction: ActivationFunction) { + this.selectedActivationFunctionName = activationFunction; + } + + setNumLayers(numLayers: number) { + this.numLayers = numLayers; + } + + setZ1Scale(z1Scale: number) { + this.z1Scale = z1Scale; + } + + setZ2Scale(z2Scale: number) { + this.z2Scale = z2Scale; + } + + start() { + this.isInferring = true; + this.runInferenceLoop(); + } + + private runInferenceLoop() { + if (!this.isInferring) { + return; + } + + const colorModeIndex = + this.colorModeNames.indexOf(this.selectedColorModeName); + const outputDimensions = + colorModeOutputDimensions[this.selectedColorModeName]; + + this.z1Counter += 1 / this.z1Scale; + this.z2Counter += 1 / this.z2Scale; + const z1 = Math.sin(this.z1Counter); + const z2 = Math.cos(this.z2Counter); + + const intermediateResults = []; + + // Add the latent variables. + const addLatentVariablesResultTex = + this.math.getTextureManager().acquireTexture(this.inputAtlas.shape); + nn_art_util.addLatentVariables( + this.gpgpu, this.addLatentVariablesShader, this.inputAtlas.getTexture(), + addLatentVariablesResultTex, this.inputAtlas.shape, z1, z2); + const inputAtlasWithLatentVariables = + Array2D.make(this.inputAtlas.shape, { + texture: addLatentVariablesResultTex, + textureShapeRC: this.inputAtlas.shape + }); + intermediateResults.push(inputAtlasWithLatentVariables); + + let lastOutput = inputAtlasWithLatentVariables; + + this.math.scope(() => { + for (let i = 0; i < this.numLayers; i++) { + const matmulResult = this.math.matMul(this.weights[i], lastOutput); + + lastOutput = (i === this.numLayers - 1) ? + this.math.sigmoid(matmulResult) : + activationFunctionMap[this.selectedActivationFunctionName]( + this.math, matmulResult); + } + nn_art_util.render( + this.gpgpu, this.renderShader, lastOutput.getTexture(), + outputDimensions, colorModeIndex); + }); + + inputAtlasWithLatentVariables.dispose(); + + requestAnimationFrame(() => this.runInferenceLoop()); + } + + stopInferenceLoop() { + this.isInferring = false; + } +} diff --git a/demos/nn-art/nn-art-demo.html b/demos/nn-art/nn-art-demo.html new file mode 100644 index 0000000000..4723393536 --- /dev/null +++ b/demos/nn-art/nn-art-demo.html @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + Abstract CPPN Art + + + + + + + + + + diff --git a/demos/nn-art/nn-art.html b/demos/nn-art/nn-art.html new file mode 100644 index 0000000000..025624d009 --- /dev/null +++ b/demos/nn-art/nn-art.html @@ -0,0 +1,97 @@ + + + + + + + + + + + + + + + diff --git a/demos/nn-art/nn-art.ts b/demos/nn-art/nn-art.ts new file mode 100644 index 0000000000..36fe423d48 --- /dev/null +++ b/demos/nn-art/nn-art.ts @@ -0,0 +1,126 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ +import '../demo-header'; +import '../demo-footer'; + +import {Array1D, Array2D, gpgpu_util, GPGPUContext, NDArrayMathGPU, Scalar, webgl_util} from '../deeplearnjs'; +// tslint:disable-next-line:no-unused-variable +import {PolymerElement, PolymerHTMLElement} from '../polymer-spec'; + +import {ActivationFunction, ColorMode, CPPN} from './cppn'; +import * as nn_art_util from './nn_art_util'; + +const CANVAS_UPSCALE_FACTOR = 3; + +const NUM_IMAGE_SPACE_VARIABLES = 3; // x, y, r +const NUM_LATENT_VARIABLES = 2; + +const MAX_NUM_LAYERS = 15; +const MAT_WIDTH = 30; +// Standard deviations for gaussian weight initialization. +const WEIGHTS_STDEV = .6; + +// tslint:disable-next-line:variable-name +export const NNArtPolymer = PolymerElement({is: 'nn-art', properties: {}}); + +export class NNArt extends NNArtPolymer { + private cppn: CPPN; + + private inferenceCanvas: HTMLCanvasElement; + + private z1Scale: number; + private z2Scale: number; + private numLayers: number; + + ready() { + this.inferenceCanvas = + this.querySelector('#inference') as HTMLCanvasElement; + + this.cppn = new CPPN(this.inferenceCanvas); + + this.inferenceCanvas.style.width = + this.inferenceCanvas.width * CANVAS_UPSCALE_FACTOR + 'px'; + this.inferenceCanvas.style.height = + this.inferenceCanvas.height * CANVAS_UPSCALE_FACTOR + 'px'; + + const currentColorElement = + this.querySelector('#colormode') as HTMLInputElement; + this.querySelector('#color-selector')!.addEventListener( + // tslint:disable-next-line:no-any + 'click', (event: any) => { + const colorMode = + (event.target as HTMLElement).getAttribute('data-val') as + ColorMode; + currentColorElement.value = colorMode; + this.cppn.setColorMode(colorMode); + }); + this.cppn.setColorMode('rgb'); + + const currentActivationFnElement = + this.querySelector('#activation-fn') as HTMLInputElement; + this.querySelector('#activation-selector')!.addEventListener( + // tslint:disable-next-line:no-any + 'click', (event: any) => { + const activationFn = + (event.target as HTMLElement).getAttribute('data-val') as + ActivationFunction; + currentActivationFnElement.value = activationFn; + this.cppn.setActivationFunction(activationFn); + }); + this.cppn.setActivationFunction('tanh'); + + const layersSlider = + this.querySelector('#layers-slider') as HTMLInputElement; + const layersCountElement = + this.querySelector('#layers-count') as HTMLDivElement; + layersSlider!.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + this.numLayers = (event as any).target.value; + layersCountElement.innerText = '' + this.numLayers; + this.cppn.setNumLayers(this.numLayers); + }); + this.numLayers = +layersSlider.value; + layersCountElement.innerText = '' + this.numLayers; + this.cppn.setNumLayers(this.numLayers); + + const z1Slider = this.querySelector('#z1-slider') as HTMLInputElement; + z1Slider.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + this.z1Scale = (event as any).target.value; + this.cppn.setZ1Scale(this.z1Scale); + }); + this.z1Scale = +z1Slider.value; + this.cppn.setZ1Scale(this.z1Scale); + + const z2Slider = this.querySelector('#z2-slider') as HTMLInputElement; + z2Slider.addEventListener('input', (event) => { + // tslint:disable-next-line:no-any + this.z2Scale = (event as any).target.value; + this.cppn.setZ2Scale(this.z1Scale); + }); + this.z2Scale = +z2Slider.value; + this.cppn.setZ2Scale(this.z2Scale); + + const randomizeButton = this.querySelector('#random') as HTMLButtonElement; + randomizeButton.addEventListener('click', () => { + this.cppn.generateWeights(MAT_WIDTH, WEIGHTS_STDEV); + }); + + this.cppn.generateWeights(MAT_WIDTH, WEIGHTS_STDEV); + this.cppn.start(); + } +} + +document.registerElement(NNArt.prototype.is, NNArt); diff --git a/demos/nn-art/nn_art_util.ts b/demos/nn-art/nn_art_util.ts new file mode 100644 index 0000000000..5e2a2bb7d0 --- /dev/null +++ b/demos/nn-art/nn_art_util.ts @@ -0,0 +1,179 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Array2D, GPGPUContext, webgl_util} from '../deeplearnjs'; + +export function createInputAtlas( + imageSize: number, inputNumDimensions: number, numLatentVariables: number) { + const coords = new Float32Array( + imageSize * imageSize * (inputNumDimensions + numLatentVariables)); + let dst = 0; + for (let d = 0; d < inputNumDimensions + numLatentVariables; d++) { + for (let i = 0; i < imageSize * imageSize; i++) { + const x = i % imageSize; + const y = Math.floor(i / imageSize); + const coord = imagePixelToNormalizedCoord( + x, y, imageSize, imageSize, numLatentVariables); + coords[dst++] = coord[d]; + } + } + + return Array2D.new( + [inputNumDimensions + numLatentVariables, imageSize * imageSize], coords); +} + +export function getAddLatentVariablesShader( + gpgpu: GPGPUContext, inputNumDimensions: number): WebGLProgram { + const fragmentShaderSource = ` + precision highp float; + uniform sampler2D source; + varying vec2 resultUV; + + uniform vec2 z; + + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + vec2 outputCR = floor(gl_FragCoord.xy); + if (outputCR[1] == ${inputNumDimensions}.0) { + gl_FragColor = vec4(z[0], 0, 0, 0); + } else if (outputCR[1] > ${inputNumDimensions}.0) { + gl_FragColor = vec4(z[1], 0, 0, 0); + } else { + gl_FragColor = texture2D(source, resultUV); + } + }`; + return gpgpu.createProgram(fragmentShaderSource); +} + +export function addLatentVariables( + gpgpu: GPGPUContext, addZShader: WebGLProgram, sourceTex: WebGLTexture, + resultTex: WebGLTexture, shapeRowCol: [number, number], z1: number, + z2: number) { + gpgpu.setOutputMatrixTexture(resultTex, shapeRowCol[0], shapeRowCol[1]); + gpgpu.setProgram(addZShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + const zLoc = gpgpu.getUniformLocation('z'); + gpgpu.gl.uniform2f(zLoc, z1, z2); + gpgpu.executeProgram(); +} + +export function getRenderShader( + gpgpu: GPGPUContext, imageSize: number): WebGLProgram { + const fragmentShaderSource = ` + precision highp float; + uniform sampler2D source; + varying vec2 resultUV; + + uniform int colorMode; + uniform float outputNumDimensions; + + const float destinationSize = ${imageSize}.0; + + const mat3 yuv2rgb = mat3( + 1, 1, 1, + 0, -.34413, 1.772, + 1.402, -.71414, 0); + + vec3 hsv2rgb(vec3 c) { + vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); + return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); + } + + void main() { + vec2 outputCR = floor(gl_FragCoord.xy); + float inputC = outputCR.y * destinationSize + outputCR.x; + float u = (inputC + 0.5) / ${imageSize * imageSize}.0; + + vec4 inputR = vec4(0.0, 1.0, 2.0, 3.0); + vec4 v = (inputR + 0.5) / outputNumDimensions; + + vec4 values = vec4( + texture2D(source, vec2(u, v[0])).r, + texture2D(source, vec2(u, v[1])).r, + texture2D(source, vec2(u, v[2])).r, + texture2D(source, vec2(u, v[3])).r); + + if (colorMode == 0) { + // RGB + gl_FragColor = vec4(values.rgb, 1.0); + } else if (colorMode == 1) { + // RGBA + gl_FragColor = values; + } else if (colorMode == 2) { + // HSV + vec3 rgb = hsv2rgb(values.rgb); + gl_FragColor = vec4(rgb, 1.0); + } else if (colorMode == 3) { + // HSVA + vec3 rgb = hsv2rgb(values.rgb); + gl_FragColor = vec4(rgb, values[3]); + } else if (colorMode == 4 || colorMode == 5) { + // YUV + values[0] = clamp(values[0], 0.2, 0.8); + values[1] = values[1] - 0.5; + values[2] = values[2] - 0.5; + vec3 rgb = yuv2rgb * values.rgb; + if (colorMode == 4) { + // YUV + gl_FragColor = vec4(rgb, 1.0); + } else if (colorMode == 5) { + // YUVA + gl_FragColor = vec4(rgb, values.a); + } + } else if (colorMode == 6) { + gl_FragColor = vec4(values[0], values[0], values[0], 1.0); + } + }`; + + return gpgpu.createProgram(fragmentShaderSource); +} + +export function render( + gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture, + outputNumDimensions: number, colorMode: number) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + const colorModeLoc = gpgpu.getUniformLocation('colorMode'); + gpgpu.gl.uniform1i(colorModeLoc, colorMode); + const outputNumDimensionsLoc = + gpgpu.getUniformLocation('outputNumDimensions'); + gpgpu.gl.uniform1f(outputNumDimensionsLoc, outputNumDimensions); + gpgpu.executeProgram(); +} + +// Normalizes x, y to -.5 <=> +.5, adds a radius term, and pads zeros with the +// number of z parameters that will get added by the add z shader. +export function imagePixelToNormalizedCoord( + x: number, y: number, imageWidth: number, imageHeight: number, + zSize: number): number[] { + const halfWidth = imageWidth * 0.5; + const halfHeight = imageHeight * 0.5; + const normX = (x - halfWidth) / imageWidth; + const normY = (y - halfHeight) / imageHeight; + + const r = Math.sqrt(normX * normX + normY * normY); + + const result = [normX, normY, r]; + + // Pad with zeros the number of latent terms, these get added on the GPU as + // uniforms. + for (let i = 0; i < zSize; i++) { + result.push(0); + } + return result; +} diff --git a/demos/one_plus_one/index.html b/demos/one_plus_one/index.html new file mode 100644 index 0000000000..5d93ccc4fb --- /dev/null +++ b/demos/one_plus_one/index.html @@ -0,0 +1,22 @@ + + + + + +1 + 1 = +
Calculating...
+ + \ No newline at end of file diff --git a/demos/one_plus_one/one_plus_one.ts b/demos/one_plus_one/one_plus_one.ts new file mode 100644 index 0000000000..5839012b6b --- /dev/null +++ b/demos/one_plus_one/one_plus_one.ts @@ -0,0 +1,52 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ +import {Graph, NDArrayMath, NDArrayMathGPU, Scalar, Session, Tensor} from '../deeplearnjs'; + +class Adder { + inputTensorA: Tensor; + inputTensorB: Tensor; + sum: Tensor; + session: Session; + math: NDArrayMath = new NDArrayMathGPU(); + setupSession(): void { + const graph = new Graph(); + + this.inputTensorA = graph.placeholder('A', []); + this.inputTensorB = graph.placeholder('B', []); + this.sum = graph.add(this.inputTensorA, this.inputTensorB); + this.session = new Session(graph, this.math); + } + + computeSum(a: number, b: number): number { + const feeds = [ + {tensor: this.inputTensorA, data: Scalar.new(a)}, + {tensor: this.inputTensorB, data: Scalar.new(b)} + ]; + let result; + this.math.scope(() => { + result = this.session.eval(this.sum, feeds).get(); + }); + return result; + } +} + + +const adder = new Adder(); +adder.setupSession(); +const result = adder.computeSum(1, 1); + +const outputEl = document.getElementById('output'); +if (!outputEl) throw new Error('output element not found'); +outputEl.innerText = String(result); diff --git a/demos/paint-image/bundle.js b/demos/paint-image/bundle.js new file mode 100644 index 0000000000..d78bd7f054 --- /dev/null +++ b/demos/paint-image/bundle.js @@ -0,0 +1,8333 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + var curLowerBounds; + var curUpperBounds; + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound; + } + else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + }; + InMemoryDataset.prototype.isNormalized = function (dataIndex) { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + }; + InMemoryDataset.prototype.removeNormalization = function (dataIndex) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + if (!this.isNormalized(dataIndex)) { + return; + } + this.dataset[dataIndex] = this.normalizeExamplesToRange(this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + }; + InMemoryDataset.prototype.unnormalizeExamples = function (examples, dataIndex) { + if (!this.isNormalized(dataIndex)) { + return examples; + } + return this.normalizeExamplesToRange(examples, this.normalizationInfo[dataIndex].lowerBound, this.normalizationInfo[dataIndex].upperBound, this.normalizationInfo[dataIndex].minValues, this.normalizationInfo[dataIndex].maxValues); + }; + InMemoryDataset.prototype.dispose = function () { + if (this.dataset == null) { + return; + } + for (var i = 0; i < this.dataset.length; i++) { + for (var j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + }; + return InMemoryDataset; +}()); +exports.InMemoryDataset = InMemoryDataset; + +},{"./math/ndarray":23,"./util":87}],8:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_layers_1 = require("./graph_layers"); +var concat3d_util = require("./math/concat3d_util"); +var conv_util = require("./math/conv_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var Graph = (function () { + function Graph() { + this.nodes = []; + this.layers = new graph_layers_1.GraphLayers(this); + } + Graph.prototype.variable = function (name, data) { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + }; + Graph.prototype.placeholder = function (name, shape) { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + }; + Graph.prototype.constant = function (value) { + var finalValue; + if (typeof value === 'number') { + finalValue = ndarray_1.Scalar.new(value); + } + else if (value instanceof ndarray_1.NDArray) { + finalValue = value; + } + else if (value instanceof Array) { + var vals = new Float32Array(util.flatten(value)); + finalValue = ndarray_1.NDArray.make(util.inferShape(value), { values: vals }); + } + else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + }; + Graph.prototype.reshape = function (x, shape) { + return this.addNodeAndReturnOutput(new ReshapeNode(this, 'Reshape', x, shape)); + }; + Graph.prototype.fusedLinearCombination = function (x1, x2, c1, c2) { + return this.addNodeAndReturnOutput(new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + }; + Graph.prototype.add = function (x1, x2) { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + }; + Graph.prototype.subtract = function (x1, x2) { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + }; + Graph.prototype.multiply = function (x1, x2) { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + }; + Graph.prototype.divide = function (x1, x2) { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + }; + Graph.prototype.reduceSum = function (x) { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + }; + Graph.prototype.concat3d = function (x1, x2, axis) { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + }; + Graph.prototype.matmul = function (x1, x2) { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + }; + Graph.prototype.conv2d = function (x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new Convolution2DNode(this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + }; + Graph.prototype.maxPool = function (x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + return this.addNodeAndReturnOutput(new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + }; + Graph.prototype.exp = function (x) { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + }; + Graph.prototype.log = function (x) { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + }; + Graph.prototype.relu = function (x) { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + }; + Graph.prototype.tanh = function (x) { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + }; + Graph.prototype.sigmoid = function (x) { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + }; + Graph.prototype.square = function (x) { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + }; + Graph.prototype.softmax = function (x) { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + }; + Graph.prototype.softmaxCrossEntropyCost = function (x, target) { + return this.addNodeAndReturnOutput(new SoftmaxCrossEntropyCostNode(this, x, target)); + }; + Graph.prototype.meanSquaredCost = function (label, prediction) { + return this.addNodeAndReturnOutput(new MeanSquaredCostNode(this, label, prediction)); + }; + Graph.prototype.argmax = function (x) { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + }; + Graph.prototype.argmaxEquals = function (x1, x2) { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + }; + Graph.prototype.addNodeAndReturnOutput = function (node) { + this.nodes.push(node); + node.validate(); + return node.output; + }; + Graph.prototype.getNodes = function () { + return this.nodes; + }; + return Graph; +}()); +exports.Graph = Graph; +var Tensor = (function () { + function Tensor(shape) { + this.shape = shape; + this.id = Tensor.nextID++; + } + return Tensor; +}()); +Tensor.nextID = 0; +exports.Tensor = Tensor; +var Node = (function () { + function Node(graph, name, inputs, output) { + this.graph = graph; + this.name = name; + this.inputs = inputs; + this.output = output; + this.id = Node.nextID++; + output.node = this; + } + return Node; +}()); +Node.nextID = 0; +exports.Node = Node; +var VariableNode = (function (_super) { + __extends(VariableNode, _super); + function VariableNode(graph, name, data) { + var _this = _super.call(this, graph, name, {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + VariableNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + }; + return VariableNode; +}(Node)); +exports.VariableNode = VariableNode; +var PlaceholderNode = (function (_super) { + __extends(PlaceholderNode, _super); + function PlaceholderNode(graph, name, shape) { + return _super.call(this, graph, name, {}, new Tensor(shape)) || this; + } + PlaceholderNode.prototype.validate = function () { }; + return PlaceholderNode; +}(Node)); +exports.PlaceholderNode = PlaceholderNode; +var ConstantNode = (function (_super) { + __extends(ConstantNode, _super); + function ConstantNode(graph, data) { + var _this = _super.call(this, graph, 'Constant', {}, new Tensor(data.shape)) || this; + _this.data = data; + return _this; + } + ConstantNode.prototype.validate = function () { + util.assert(this.data != null, 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + }; + return ConstantNode; +}(Node)); +exports.ConstantNode = ConstantNode; +var ReshapeNode = (function (_super) { + __extends(ReshapeNode, _super); + function ReshapeNode(graph, name, x, shape) { + var _this = _super.call(this, graph, name, { x: x }, new Tensor(shape)) || this; + _this.name = name; + _this.x = x; + _this.shape = shape; + return _this; + } + ReshapeNode.prototype.validate = function () { + var xSize = util.sizeFromShape(this.x.shape); + var shapeSize = util.sizeFromShape(this.shape); + util.assert(xSize === shapeSize, 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + }; + return ReshapeNode; +}(Node)); +ReshapeNode.X = 'x'; +exports.ReshapeNode = ReshapeNode; +var FusedLinearCombinationNode = (function (_super) { + __extends(FusedLinearCombinationNode, _super); + function FusedLinearCombinationNode(graph, t1, t2, c1, c2) { + var _this = _super.call(this, graph, 'Linear Combination', { t1: t1, t2: t2, c1: c1, c2: c2 }, new Tensor(t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.c1 = c1; + _this.c2 = c2; + return _this; + } + FusedLinearCombinationNode.prototype.validate = function () { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error('Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error('Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + }; + return FusedLinearCombinationNode; +}(Node)); +FusedLinearCombinationNode.T1 = 't1'; +FusedLinearCombinationNode.T2 = 't2'; +FusedLinearCombinationNode.C1 = 'c1'; +FusedLinearCombinationNode.C2 = 'c2'; +exports.FusedLinearCombinationNode = FusedLinearCombinationNode; +var AddNode = (function (_super) { + __extends(AddNode, _super); + function AddNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Add', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + AddNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return AddNode; +}(Node)); +AddNode.T1 = 't1'; +AddNode.T2 = 't2'; +exports.AddNode = AddNode; +var SubtractNode = (function (_super) { + __extends(SubtractNode, _super); + function SubtractNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Subtract', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + SubtractNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return SubtractNode; +}(Node)); +SubtractNode.T1 = 't1'; +SubtractNode.T2 = 't2'; +exports.SubtractNode = SubtractNode; +var MultiplyNode = (function (_super) { + __extends(MultiplyNode, _super); + function MultiplyNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Multiply', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + MultiplyNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return MultiplyNode; +}(Node)); +MultiplyNode.T1 = 't1'; +MultiplyNode.T2 = 't2'; +exports.MultiplyNode = MultiplyNode; +var DivideNode = (function (_super) { + __extends(DivideNode, _super); + function DivideNode(graph, t1, t2) { + var _this = _super.call(this, graph, 'Divide', { t1: t1, t2: t2 }, new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)) || this; + _this.t1 = t1; + _this.t2 = t2; + return _this; + } + DivideNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + }; + return DivideNode; +}(Node)); +DivideNode.T1 = 't1'; +DivideNode.T2 = 't2'; +exports.DivideNode = DivideNode; +var ReduceSumNode = (function (_super) { + __extends(ReduceSumNode, _super); + function ReduceSumNode(graph, x) { + return _super.call(this, graph, 'ReduceSum', { x: x }, new Tensor([])) || this; + } + ReduceSumNode.prototype.validate = function () { }; + return ReduceSumNode; +}(Node)); +ReduceSumNode.X = 'x'; +exports.ReduceSumNode = ReduceSumNode; +var Concat3DNode = (function (_super) { + __extends(Concat3DNode, _super); + function Concat3DNode(graph, x1, x2, axis) { + var _this = _super.call(this, graph, 'Concat3D', { x1: x1, x2: x2 }, new Tensor(concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis))) || this; + _this.x1 = x1; + _this.x2 = x2; + _this.axis = axis; + return _this; + } + Concat3DNode.prototype.validate = function () { + concat3d_util.assertConcat3DShapesMatch(this.x1.shape, this.x2.shape, this.axis); + }; + return Concat3DNode; +}(Node)); +Concat3DNode.X1 = 'x1'; +Concat3DNode.X2 = 'x2'; +Concat3DNode.AXIS = 'axis'; +exports.Concat3DNode = Concat3DNode; +function getMatMulOutputShape(x1Shape, x2Shape) { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } + else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } + else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} +var MatMulNode = (function (_super) { + __extends(MatMulNode, _super); + function MatMulNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'MatMul', { x1: x1, x2: x2 }, new Tensor(getMatMulOutputShape(x1.shape, x2.shape))) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + MatMulNode.prototype.validate = function () { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } + else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert(this.x1.shape[1] === this.x2.shape[0], 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } + else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert(this.x1.shape[0] === this.x2.shape[0], 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } + else { + throw new Error('Error adding matmul op: inputs must be vectors or matrices.'); + } + }; + return MatMulNode; +}(Node)); +MatMulNode.X1 = 'x1'; +MatMulNode.X2 = 'x2'; +exports.MatMulNode = MatMulNode; +var Convolution2DNode = (function (_super) { + __extends(Convolution2DNode, _super); + function Convolution2DNode(graph, x, w, b, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Convolution 2D', { x: x, w: w, b: b }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad))) || this; + _this.x = x; + _this.w = w; + _this.b = b; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + Convolution2DNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert(this.w.shape.length === 4, 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert(this.b.shape.length === 1, 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + util.assert(this.x.shape[2] === this.w.shape[2], 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + }; + return Convolution2DNode; +}(Node)); +Convolution2DNode.X = 'x'; +Convolution2DNode.W = 'w'; +Convolution2DNode.B = 'b'; +exports.Convolution2DNode = Convolution2DNode; +var MaxPoolNode = (function (_super) { + __extends(MaxPoolNode, _super); + function MaxPoolNode(graph, x, fieldSize, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this, graph, 'Max pool', { x: x }, new Tensor(conv_util.computeOutputShape3D(x.shape, fieldSize, x.shape[2], stride, zeroPad))) || this; + _this.x = x; + _this.fieldSize = fieldSize; + _this.stride = stride; + _this.zeroPad = zeroPad; + return _this; + } + MaxPoolNode.prototype.validate = function () { + util.assert(this.x.shape.length === 3, 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + }; + return MaxPoolNode; +}(Node)); +MaxPoolNode.X = 'x'; +exports.MaxPoolNode = MaxPoolNode; +var ReLUNode = (function (_super) { + __extends(ReLUNode, _super); + function ReLUNode(graph, x) { + return _super.call(this, graph, 'ReLU', { x: x }, new Tensor(x.shape)) || this; + } + ReLUNode.prototype.validate = function () { }; + return ReLUNode; +}(Node)); +ReLUNode.X = 'x'; +exports.ReLUNode = ReLUNode; +var ExpNode = (function (_super) { + __extends(ExpNode, _super); + function ExpNode(graph, x) { + return _super.call(this, graph, 'Exp', { x: x }, new Tensor(x.shape)) || this; + } + ExpNode.prototype.validate = function () { }; + return ExpNode; +}(Node)); +ExpNode.X = 'x'; +exports.ExpNode = ExpNode; +var LogNode = (function (_super) { + __extends(LogNode, _super); + function LogNode(graph, x) { + return _super.call(this, graph, 'Log', { x: x }, new Tensor(x.shape)) || this; + } + LogNode.prototype.validate = function () { }; + return LogNode; +}(Node)); +LogNode.X = 'x'; +exports.LogNode = LogNode; +var TanHNode = (function (_super) { + __extends(TanHNode, _super); + function TanHNode(graph, x) { + return _super.call(this, graph, 'TanH', { x: x }, new Tensor(x.shape)) || this; + } + TanHNode.prototype.validate = function () { }; + return TanHNode; +}(Node)); +TanHNode.X = 'x'; +exports.TanHNode = TanHNode; +var SigmoidNode = (function (_super) { + __extends(SigmoidNode, _super); + function SigmoidNode(graph, x) { + return _super.call(this, graph, 'Sigmoid', { x: x }, new Tensor(x.shape)) || this; + } + SigmoidNode.prototype.validate = function () { }; + return SigmoidNode; +}(Node)); +SigmoidNode.X = 'x'; +exports.SigmoidNode = SigmoidNode; +var SquareNode = (function (_super) { + __extends(SquareNode, _super); + function SquareNode(graph, x) { + return _super.call(this, graph, 'Square', { x: x }, new Tensor(x.shape)) || this; + } + SquareNode.prototype.validate = function () { }; + return SquareNode; +}(Node)); +SquareNode.X = 'x'; +exports.SquareNode = SquareNode; +var SoftmaxCrossEntropyCostNode = (function (_super) { + __extends(SoftmaxCrossEntropyCostNode, _super); + function SoftmaxCrossEntropyCostNode(graph, x, target) { + var _this = _super.call(this, graph, 'SoftmaxCrossEntropyCost', { x: x, target: target }, new Tensor([])) || this; + _this.x = x; + _this.target = target; + return _this; + } + SoftmaxCrossEntropyCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x.shape, this.target.shape), 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + }; + return SoftmaxCrossEntropyCostNode; +}(Node)); +SoftmaxCrossEntropyCostNode.X = 'x'; +SoftmaxCrossEntropyCostNode.TARGET = 'target'; +exports.SoftmaxCrossEntropyCostNode = SoftmaxCrossEntropyCostNode; +var SoftmaxNode = (function (_super) { + __extends(SoftmaxNode, _super); + function SoftmaxNode(graph, x) { + var _this = _super.call(this, graph, 'Softmax', { x: x }, new Tensor(x.shape)) || this; + _this.x = x; + return _this; + } + SoftmaxNode.prototype.validate = function () { + util.assert(this.x.shape.length === 1, 'The input to a softmax must be a 1-D tensor'); + util.assert(this.x.shape[0] >= 2, 'The input to a softmax must have at least 2 values'); + }; + return SoftmaxNode; +}(Node)); +SoftmaxNode.X = 'x'; +exports.SoftmaxNode = SoftmaxNode; +var MeanSquaredCostNode = (function (_super) { + __extends(MeanSquaredCostNode, _super); + function MeanSquaredCostNode(graph, label, prediction) { + var _this = _super.call(this, graph, 'Mean Squared Cost', { label: label, prediction: prediction }, new Tensor([])) || this; + _this.label = label; + _this.prediction = prediction; + return _this; + } + MeanSquaredCostNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.label.shape, this.prediction.shape), 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + }; + return MeanSquaredCostNode; +}(Node)); +MeanSquaredCostNode.LABEL = 'label'; +MeanSquaredCostNode.PREDICTION = 'prediction'; +exports.MeanSquaredCostNode = MeanSquaredCostNode; +var ArgMaxNode = (function (_super) { + __extends(ArgMaxNode, _super); + function ArgMaxNode(graph, x) { + var _this = _super.call(this, graph, 'ArgMax', { x: x }, new Tensor([1])) || this; + _this.x = x; + return _this; + } + ArgMaxNode.prototype.validate = function () { + util.assert(util.sizeFromShape(this.x.shape) > 0, 'Error adding argmax op: input tensor must have at least one entry.'); + }; + return ArgMaxNode; +}(Node)); +ArgMaxNode.X = 'x'; +exports.ArgMaxNode = ArgMaxNode; +var ArgMaxEqualsNode = (function (_super) { + __extends(ArgMaxEqualsNode, _super); + function ArgMaxEqualsNode(graph, x1, x2) { + var _this = _super.call(this, graph, 'ArgMaxEquals', { x1: x1, x2: x2 }, new Tensor([1])) || this; + _this.x1 = x1; + _this.x2 = x2; + return _this; + } + ArgMaxEqualsNode.prototype.validate = function () { + util.assert(util.arraysEqual(this.x1.shape, this.x2.shape), 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + }; + return ArgMaxEqualsNode; +}(Node)); +ArgMaxEqualsNode.X1 = 'x1'; +ArgMaxEqualsNode.X2 = 'x2'; +exports.ArgMaxEqualsNode = ArgMaxEqualsNode; +var SplitNode = (function (_super) { + __extends(SplitNode, _super); + function SplitNode(graph, x) { + var _this = _super.call(this, graph, 'SplitNode', { x: x }, new Tensor(x.shape)) || this; + _this.outputs = []; + return _this; + } + SplitNode.prototype.getNewOutputTensor = function () { + var output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + }; + SplitNode.prototype.validate = function () { }; + return SplitNode; +}(Node)); +SplitNode.X = 'x'; +exports.SplitNode = SplitNode; + +},{"./graph_layers":9,"./math/concat3d_util":16,"./math/conv_util":17,"./math/ndarray":23,"./util":87}],9:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var initializers_1 = require("./initializers"); +var GraphLayers = (function () { + function GraphLayers(g) { + this.g = g; + } + GraphLayers.prototype.dense = function (name, x, units, activation, useBias, kernelInitializer, biasInitializer) { + if (activation === void 0) { activation = null; } + if (useBias === void 0) { useBias = true; } + if (kernelInitializer === void 0) { kernelInitializer = new initializers_1.VarianceScalingInitializer(); } + if (biasInitializer === void 0) { biasInitializer = new initializers_1.ZerosInitializer(); } + var weights = this.g.variable(name + '-weights', kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + var out = this.g.matmul(x, weights); + if (useBias) { + var bias = this.g.variable(name + '-bias', biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + if (activation != null) { + out = activation(out); + } + return out; + }; + return GraphLayers; +}()); +exports.GraphLayers = GraphLayers; + +},{"./initializers":13}],10:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var session_1 = require("./session"); +var DEFAULT_EVAL_INTERVAL_MS = 1500; +var DEFAULT_COST_INTERVAL_MS = 500; +var DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; +var MetricReduction; +(function (MetricReduction) { + MetricReduction[MetricReduction["SUM"] = 0] = "SUM"; + MetricReduction[MetricReduction["MEAN"] = 1] = "MEAN"; +})(MetricReduction = exports.MetricReduction || (exports.MetricReduction = {})); +var GraphRunner = (function () { + function GraphRunner(math, session, eventObserver) { + this.math = math; + this.session = session; + this.eventObserver = eventObserver; + this.lastCostTimestamp = 0; + this.lastEvalTimestamp = 0; + this.totalIdleTimeMs = 0; + this.resetStatistics(); + this.zeroScalar = ndarray_1.Scalar.new(0); + } + GraphRunner.prototype.resetStatistics = function () { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + }; + GraphRunner.prototype.train = function (costTensor, trainFeedEntries, batchSize, optimizer, numBatches, metricTensor, metricFeedEntries, metricBatchSize, metricReduction, evalIntervalMs, costIntervalMs) { + if (metricReduction === void 0) { metricReduction = MetricReduction.MEAN; } + if (evalIntervalMs === void 0) { evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS; } + if (costIntervalMs === void 0) { costIntervalMs = DEFAULT_COST_INTERVAL_MS; } + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = ndarray_1.Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + }; + GraphRunner.prototype.stopTraining = function () { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + }; + GraphRunner.prototype.resumeTraining = function () { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + }; + GraphRunner.prototype.trainNetwork = function () { + var _this = this; + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + var start = performance.now(); + var shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + var costReduction = shouldComputeCost ? session_1.CostReduction.MEAN : session_1.CostReduction.NONE; + this.math.scope(function (keep) { + var avgCost = _this.session.train(_this.costTensor, _this.trainFeedEntries, _this.batchSize, _this.optimizer, costReduction); + if (shouldComputeCost) { + var trainTime = performance.now() - start; + _this.eventObserver.avgCostCallback(avgCost); + if (_this.eventObserver.trainExamplesPerSecCallback != null) { + var examplesPerSec = (_this.batchSize * 1000 / trainTime); + _this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + if (_this.eventObserver.metricCallback != null && + _this.metricFeedEntries != null && + start - _this.lastEvalTimestamp > _this.metricIntervalMs) { + _this.lastEvalTimestamp = start; + if (_this.lastComputedMetric != null) { + _this.lastComputedMetric.dispose(); + } + _this.lastComputedMetric = _this.computeMetric(); + _this.eventObserver.metricCallback(_this.lastComputedMetric); + } + if (_this.eventObserver.totalTimeCallback != null) { + _this.eventObserver.totalTimeCallback((start - _this.trainStartTimestamp) / 1000); + } + _this.batchesTrainedThisRun++; + _this.totalBatchesTrained++; + if (_this.eventObserver.batchesTrainedCallback != null) { + _this.eventObserver.batchesTrainedCallback(_this.totalBatchesTrained); + } + }); + setTimeout(function () { return _this.trainNetwork(); }); + }; + GraphRunner.prototype.infer = function (inferenceTensor, inferenceFeedEntries, inferenceExampleIntervalMs, inferenceExampleCount, numPasses) { + var _this = this; + if (inferenceExampleIntervalMs === void 0) { inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS; } + if (inferenceExampleCount === void 0) { inferenceExampleCount = 5; } + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error('Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + for (var i = 0; i < inferenceFeedEntries.length; i++) { + var feedEntry = inferenceFeedEntries[i]; + if (feedEntry.data instanceof ndarray_1.NDArray) { + throw new Error('Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(function () { return _this.inferNetwork(); }); + } + this.isInferring = true; + }; + GraphRunner.prototype.inferNetwork = function () { + var _this = this; + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + this.math.scope(function (keep, track) { + var feeds = []; + var inferenceValues = []; + var start = performance.now(); + for (var i = 0; i < _this.inferenceExampleCount; i++) { + var ndarrayFeedEntries = []; + for (var j = 0; j < _this.inferenceFeedEntries.length; j++) { + var feedEntry = _this.inferenceFeedEntries[j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: track(feedEntry.data.getNextCopy(_this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + inferenceValues.push(_this.session.eval(_this.inferenceTensor, ndarrayFeedEntries)); + } + if (_this.eventObserver.inferenceExamplesPerSecCallback != null) { + inferenceValues[inferenceValues.length - 1].getValues(); + var inferenceExamplesPerSecTime = performance.now() - start; + var examplesPerSec = (_this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + _this.eventObserver.inferenceExamplesPerSecCallback(examplesPerSec); + } + if (_this.eventObserver.inferenceExamplesCallback != null) { + _this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + _this.inferencePassesThisRun++; + }); + setTimeout(function () { return _this.inferNetwork(); }, this.inferenceExampleIntervalMs); + }; + GraphRunner.prototype.stopInferring = function () { + this.isInferring = false; + }; + GraphRunner.prototype.isInferenceRunning = function () { + return this.isInferring; + }; + GraphRunner.prototype.computeMetric = function () { + var _this = this; + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + var metric = this.zeroScalar; + return this.math.scope(function (keep) { + for (var i = 0; i < _this.metricBatchSize; i++) { + var metricValue = _this.session.eval(_this.metricTensor, _this.metricFeedEntries); + metric = _this.math.add(metric, metricValue); + } + if (_this.metricReduction === MetricReduction.MEAN) { + metric = _this.math.divide(metric, _this.metricBatchSizeScalar); + } + return metric; + }); + }; + GraphRunner.prototype.getTotalBatchesTrained = function () { + return this.totalBatchesTrained; + }; + GraphRunner.prototype.getLastComputedMetric = function () { + return this.lastComputedMetric; + }; + GraphRunner.prototype.setMath = function (math) { + this.math = math; + }; + GraphRunner.prototype.setSession = function (session) { + this.session = session; + }; + GraphRunner.prototype.setInferenceTensor = function (inferenceTensor) { + this.inferenceTensor = inferenceTensor; + }; + GraphRunner.prototype.setInferenceExampleCount = function (inferenceExampleCount) { + this.inferenceExampleCount = inferenceExampleCount; + }; + return GraphRunner; +}()); +exports.GraphRunner = GraphRunner; + +},{"./math/ndarray":23,"./session":83}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var priority_queue = require("./priority_queue"); +var priority_queue_1 = require("./priority_queue"); +function getUnorderedEvaluationSet(nodes, terminatingNodes) { + var terminatingNodeMap = {}; + var seen = {}; + var set = []; + var visit = nodes.slice(); + terminatingNodes.forEach(function (node) { return terminatingNodeMap[node.id] = node; }); + var _loop_1 = function () { + var cur = visit.pop(); + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(function (inputName) { return cur.inputs[inputName]; }) + .forEach(function (input) { return visit.push(input.node); }); + } + set.push(cur); + seen[cur.id] = cur; + } + }; + while (visit.length !== 0) { + _loop_1(); + } + return set; +} +exports.getUnorderedEvaluationSet = getUnorderedEvaluationSet; +function getOrderedEvaluationSet(unorderedEvaluationSet) { + var set = []; + var nodeIndices = {}; + var pendingDependencies = {}; + var nodeQueue = new priority_queue_1.PriorityQueue(function (a, b) { return priority_queue.defaultCompare(pendingDependencies[a.id], pendingDependencies[b.id]); }, function (node, newIndex) { return nodeIndices[node.id] = newIndex; }); + unorderedEvaluationSet.forEach(function (node) { return pendingDependencies[node.id] = 0; }); + unorderedEvaluationSet.forEach(function (node) { return Object.keys(node.inputs) + .map(function (key) { return node.inputs[key]; }) + .forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + }); }); + unorderedEvaluationSet.forEach(function (node) { return nodeQueue.enqueue(node); }); + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + Object.keys(set[0].inputs).map(function (key) { return set[0].inputs[key]; }).forEach(function (input) { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + return set; +} +exports.getOrderedEvaluationSet = getOrderedEvaluationSet; +function isInputNode(node) { + return Object.keys(node.inputs).length === 0; +} +exports.isInputNode = isInputNode; +function shouldBackProp(t) { + return !(t.node instanceof graph_1.ConstantNode); +} +exports.shouldBackProp = shouldBackProp; +function isPassthroughNode(node, map) { + var keys = Object.keys(node.inputs); + for (var i = 0; i < keys.length; i++) { + var input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} +exports.isPassthroughNode = isPassthroughNode; + +},{"./graph":8,"./priority_queue":82}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("./math/conv_util"); +exports.conv_util = conv_util; +var gpgpu_util = require("./math/webgl/gpgpu_util"); +exports.gpgpu_util = gpgpu_util; +var render_ndarray_gpu_util = require("./math/webgl/render_ndarray_gpu_util"); +exports.render_ndarray_gpu_util = render_ndarray_gpu_util; +var webgl_util = require("./math/webgl/webgl_util"); +exports.webgl_util = webgl_util; +var util = require("./util"); +exports.util = util; +var checkpoint_loader_1 = require("./checkpoint_loader"); +exports.CheckpointLoader = checkpoint_loader_1.CheckpointLoader; +var dataset_1 = require("./dataset"); +exports.InMemoryDataset = dataset_1.InMemoryDataset; +var graph_1 = require("./graph"); +exports.Graph = graph_1.Graph; +exports.Tensor = graph_1.Tensor; +var graph_runner_1 = require("./graph_runner"); +exports.GraphRunner = graph_runner_1.GraphRunner; +exports.MetricReduction = graph_runner_1.MetricReduction; +var initializers_1 = require("./initializers"); +exports.ConstantInitializer = initializers_1.ConstantInitializer; +exports.NDArrayInitializer = initializers_1.NDArrayInitializer; +exports.OnesInitializer = initializers_1.OnesInitializer; +exports.RandomNormalInitializer = initializers_1.RandomNormalInitializer; +exports.RandomTruncatedNormalInitializer = initializers_1.RandomTruncatedNormalInitializer; +exports.RandomUniformInitializer = initializers_1.RandomUniformInitializer; +exports.VarianceScalingInitializer = initializers_1.VarianceScalingInitializer; +exports.ZerosInitializer = initializers_1.ZerosInitializer; +var input_provider_1 = require("./input_provider"); +exports.InCPUMemoryShuffledInputProviderBuilder = input_provider_1.InCPUMemoryShuffledInputProviderBuilder; +exports.InGPUMemoryShuffledInputProviderBuilder = input_provider_1.InGPUMemoryShuffledInputProviderBuilder; +var math_1 = require("./math/math"); +exports.MatrixOrientation = math_1.MatrixOrientation; +exports.NDArrayMath = math_1.NDArrayMath; +var math_cpu_1 = require("./math/math_cpu"); +exports.NDArrayMathCPU = math_cpu_1.NDArrayMathCPU; +var math_gpu_1 = require("./math/math_gpu"); +exports.NDArrayMathGPU = math_gpu_1.NDArrayMathGPU; +var ndarray_1 = require("./math/ndarray"); +exports.Array1D = ndarray_1.Array1D; +exports.Array2D = ndarray_1.Array2D; +exports.Array3D = ndarray_1.Array3D; +exports.Array4D = ndarray_1.Array4D; +exports.NDArray = ndarray_1.NDArray; +exports.Scalar = ndarray_1.Scalar; +var gpgpu_context_1 = require("./math/webgl/gpgpu_context"); +exports.GPGPUContext = gpgpu_context_1.GPGPUContext; +var optimizer_1 = require("./optimizer"); +exports.Optimizer = optimizer_1.Optimizer; +var session_1 = require("./session"); +exports.CostReduction = session_1.CostReduction; +exports.Session = session_1.Session; +var sgd_optimizer_1 = require("./sgd_optimizer"); +exports.SGDOptimizer = sgd_optimizer_1.SGDOptimizer; + +},{"./checkpoint_loader":6,"./dataset":7,"./graph":8,"./graph_runner":10,"./initializers":13,"./input_provider":14,"./math/conv_util":17,"./math/math":20,"./math/math_cpu":21,"./math/math_gpu":22,"./math/ndarray":23,"./math/webgl/gpgpu_context":36,"./math/webgl/gpgpu_util":37,"./math/webgl/render_ndarray_gpu_util":49,"./math/webgl/webgl_util":59,"./optimizer":81,"./session":83,"./sgd_optimizer":85,"./util":87}],13:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var VarianceScalingInitializer = (function () { + function VarianceScalingInitializer(scale, mode, distribution) { + if (scale === void 0) { scale = 1.0; } + if (mode === void 0) { mode = 'fan_in'; } + if (distribution === void 0) { distribution = 'normal'; } + this.scale = scale; + this.mode = mode; + this.distribution = distribution; + } + VarianceScalingInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } + else if (this.mode === 'fan_out') { + n = outputUnits; + } + else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } + else { + throw new Error('Unexpected mode for variance scaling initializer: ' + this.mode); + } + if (this.distribution === 'normal') { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, 0.0, Math.sqrt(this.scale / n)); + } + else if (this.distribution === 'uniform') { + return ndarray_1.NDArray.randUniform(weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } + else { + throw new Error('Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + }; + return VarianceScalingInitializer; +}()); +exports.VarianceScalingInitializer = VarianceScalingInitializer; +var ZerosInitializer = (function () { + function ZerosInitializer() { + } + ZerosInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.zeros(weightsShape); + }; + return ZerosInitializer; +}()); +exports.ZerosInitializer = ZerosInitializer; +var OnesInitializer = (function () { + function OnesInitializer() { + } + OnesInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(1); + return values; + }; + return OnesInitializer; +}()); +exports.OnesInitializer = OnesInitializer; +var ConstantInitializer = (function () { + function ConstantInitializer(value) { + if (value === void 0) { value = 0; } + this.value = value; + } + ConstantInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + var values = ndarray_1.NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + }; + return ConstantInitializer; +}()); +exports.ConstantInitializer = ConstantInitializer; +var NDArrayInitializer = (function () { + function NDArrayInitializer(ndarray) { + this.ndarray = ndarray; + } + NDArrayInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return this.ndarray; + }; + return NDArrayInitializer; +}()); +exports.NDArrayInitializer = NDArrayInitializer; +var RandomNormalInitializer = (function () { + function RandomNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randNormal(weightsShape, this.mean, this.stdev); + }; + return RandomNormalInitializer; +}()); +exports.RandomNormalInitializer = RandomNormalInitializer; +var RandomTruncatedNormalInitializer = (function () { + function RandomTruncatedNormalInitializer(mean, stdev) { + if (mean === void 0) { mean = 0; } + if (stdev === void 0) { stdev = .05; } + this.mean = mean; + this.stdev = stdev; + } + RandomTruncatedNormalInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + }; + return RandomTruncatedNormalInitializer; +}()); +exports.RandomTruncatedNormalInitializer = RandomTruncatedNormalInitializer; +var RandomUniformInitializer = (function () { + function RandomUniformInitializer(minval, maxval) { + if (minval === void 0) { minval = -.05; } + if (maxval === void 0) { maxval = .05; } + this.minval = minval; + this.maxval = maxval; + } + RandomUniformInitializer.prototype.initialize = function (weightsShape, inputUnits, outputUnits) { + return ndarray_1.NDArray.randUniform(weightsShape, this.minval, this.maxval); + }; + return RandomUniformInitializer; +}()); +exports.RandomUniformInitializer = RandomUniformInitializer; + +},{"./math/ndarray":23}],14:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +var InMemoryShuffledInputProviderBuilder = (function () { + function InMemoryShuffledInputProviderBuilder(inputs) { + this.inputs = inputs; + this.idx = 0; + this.inputCounter = 0; + this.epoch = 0; + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + var numExamples = this.inputs[0].length; + for (var i = 0; i < this.numInputs; i++) { + util.assert(this.inputs[i].length === numExamples, 'Number of examples must match across different inputs.'); + } + for (var i = 0; i < this.numInputs; i++) { + var inputShape = this.inputs[i][0].shape; + for (var j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + InMemoryShuffledInputProviderBuilder.prototype.getCurrentExampleIndex = function () { + var returnIdx = this.idx; + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + }; + InMemoryShuffledInputProviderBuilder.prototype.getNextInput = function (inputId) { + var currentExampleIndex = this.getCurrentExampleIndex(); + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + }; + InMemoryShuffledInputProviderBuilder.prototype.getEpoch = function () { + return this.epoch; + }; + InMemoryShuffledInputProviderBuilder.prototype.getInputProviders = function () { + var inputProviders = []; + for (var i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + }; + return InMemoryShuffledInputProviderBuilder; +}()); +exports.InMemoryShuffledInputProviderBuilder = InMemoryShuffledInputProviderBuilder; +var InCPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InCPUMemoryShuffledInputProviderBuilder, _super); + function InCPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InCPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return ndarray_1.NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InCPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InCPUMemoryShuffledInputProviderBuilder = InCPUMemoryShuffledInputProviderBuilder; +var InGPUMemoryShuffledInputProviderBuilder = (function (_super) { + __extends(InGPUMemoryShuffledInputProviderBuilder, _super); + function InGPUMemoryShuffledInputProviderBuilder() { + return _super !== null && _super.apply(this, arguments) || this; + } + InGPUMemoryShuffledInputProviderBuilder.prototype.getInputProvider = function (inputId) { + var shuffledInputProvider = this; + return { + getNextCopy: function (math) { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy: function (math, copy) { + copy.dispose(); + } + }; + }; + return InGPUMemoryShuffledInputProviderBuilder; +}(InMemoryShuffledInputProviderBuilder)); +exports.InGPUMemoryShuffledInputProviderBuilder = InGPUMemoryShuffledInputProviderBuilder; + +},{"./math/ndarray":23,"./util":87}],15:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var TanHFunc = (function () { + function TanHFunc() { + } + TanHFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.tanh(x); + }); + }; + TanHFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.scalarMinusArray(ndarray_1.Scalar.ONE, ySquared); + }); + }; + return TanHFunc; +}()); +exports.TanHFunc = TanHFunc; +var ReLUFunc = (function () { + function ReLUFunc() { + } + ReLUFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.relu(x); + }); + }; + ReLUFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.step(x); + }); + }; + return ReLUFunc; +}()); +exports.ReLUFunc = ReLUFunc; +var SigmoidFunc = (function () { + function SigmoidFunc() { + } + SigmoidFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.sigmoid(x); + }); + }; + SigmoidFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + var ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + }; + return SigmoidFunc; +}()); +exports.SigmoidFunc = SigmoidFunc; +var SquareFunc = (function () { + function SquareFunc() { + } + SquareFunc.prototype.output = function (math, x) { + return math.scope(function () { + return math.elementWiseMul(x, x); + }); + }; + SquareFunc.prototype.der = function (math, x, y) { + return math.scope(function () { + return math.scalarTimesArray(ndarray_1.Scalar.TWO, x); + }); + }; + return SquareFunc; +}()); +exports.SquareFunc = SquareFunc; + +},{"./ndarray":23}],16:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function assertConcat3DShapesMatch(x1Shape, x2Shape, axis, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + util.assert(x1Shape.length === 3, errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + util.assert(axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + for (var i = 0; i < 3; i++) { + util.assert((i === axis) || (x1Shape[i] === x2Shape[i]), errorMessagePrefix + + ("Shape (" + x1Shape + ") does not match (" + x2Shape + ") along ") + + "non-concatenated axis."); + } +} +exports.assertConcat3DShapesMatch = assertConcat3DShapesMatch; +function computeConcat3DOutputShape(x1Shape, x2Shape, axis) { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + var outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape; +} +exports.computeConcat3DOutputShape = computeConcat3DOutputShape; + +},{"../util":87}],17:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +function computeOutputShape3D(inputShapeRowColDepth, fieldSize, depth, stride, zeroPad) { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + var inputRows = inputShapeRowColDepth[0]; + var inputCols = inputShapeRowColDepth[1]; + var outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputRows), "The output # of rows (" + outputRows + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + var outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert(util.isInt(outputCols), "The output # of columns (" + outputCols + ") must be an integer. Change " + + "the stride and/or zero pad parameters"); + return [outputRows, outputCols, depth]; +} +exports.computeOutputShape3D = computeOutputShape3D; +function computeDefaultPad(inputShape, fieldSize, stride) { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} +exports.computeDefaultPad = computeDefaultPad; +function computeTexShapeFrom3D(shapeRowColDepth) { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} +exports.computeTexShapeFrom3D = computeTexShapeFrom3D; +function computeWeightsShape4D(inputDepth, outputDepth, fSize) { + return [fSize, fSize, inputDepth, outputDepth]; +} +exports.computeWeightsShape4D = computeWeightsShape4D; +function computeWeightsTexShape(inputDepth, outputDepth, fieldSize) { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} +exports.computeWeightsTexShape = computeWeightsTexShape; +function computeBiasesTexShape(outputDepth) { + return [1, outputDepth]; +} +exports.computeBiasesTexShape = computeBiasesTexShape; +function computeDilatedRC(rc, origStride) { + var rowsDilated = (rc[0] - 1) * origStride + 1; + var colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} +exports.computeDilatedRC = computeDilatedRC; + +},{"../util":87}],18:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function validateShapes(sourceSize, destSize) { + var srcArea = sourceSize[0] * sourceSize[1]; + var dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + var srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + var dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error('copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} +exports.validateShapes = validateShapes; + +},{}],19:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./ndarray"); +var SquareCostFunc = (function () { + function SquareCostFunc() { + this.halfOne = ndarray_1.Scalar.new(0.5); + } + SquareCostFunc.prototype.cost = function (math, x1, x2) { + var diff = math.sub(x1, x2); + var diffSquared = math.elementWiseMul(diff, diff); + var result = math.scalarTimesArray(this.halfOne, diffSquared); + diff.dispose(); + diffSquared.dispose(); + return result; + }; + SquareCostFunc.prototype.der = function (math, x1, x2) { + return math.sub(x1, x2); + }; + SquareCostFunc.prototype.dispose = function () { + this.halfOne.dispose(); + }; + return SquareCostFunc; +}()); +exports.SquareCostFunc = SquareCostFunc; + +},{"./ndarray":23}],20:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2d_util = require("./copy2d_util"); +var ndarray_1 = require("./ndarray"); +var NDArrayMath = (function () { + function NDArrayMath(safeMode) { + this.safeMode = safeMode; + this.ndarrayScopes = []; + this.ndarraysToKeep = []; + this.activeScopeNDArraysToKeep = []; + } + NDArrayMath.prototype.scope = function (scopeFn) { + var _this = this; + this.startScope(); + var keepFn = function (ndarray) { return _this.keep(ndarray); }; + var trackFn = function (ndarray) { return _this.track(ndarray); }; + var result = scopeFn(keepFn, trackFn); + this.endScope(result); + return result; + }; + NDArrayMath.prototype.startScope = function () { + var newScope = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + var newNDArraysToKeep = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + }; + NDArrayMath.prototype.endScope = function (result) { + var _this = this; + for (var i = 0; i < this.activeScope.length; i++) { + var ndarray = this.activeScope[i]; + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof ndarray_1.NDArray && + ndarray.getData() === result.getData())) { + continue; + } + ndarray.dispose(); + } + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + if (result instanceof ndarray_1.NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } + else if (Array.isArray(result)) { + result.forEach(function (r) { + if (r instanceof ndarray_1.NDArray && + !_this.isNDArrayDataInList(r, _this.activeScopeNDArraysToKeep)) { + _this.track(r); + } + }); + } + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + }; + NDArrayMath.prototype.isNDArrayDataInList = function (ndarray, ndarrayList) { + for (var i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + }; + NDArrayMath.prototype.keep = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + }; + NDArrayMath.prototype.track = function (result) { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error('You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + }; + NDArrayMath.prototype.matMul = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = MatrixOrientation.REGULAR; } + var innerShapeA = (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var innerShapeB = (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + util.assert(a.rank === 2 && b.rank === 2, "Error in matMul: inputs must be rank 2, got ranks " + a.rank + + ("and " + b.rank + ".")); + util.assert(innerShapeA === innerShapeB, "Error in matMul: inner shapes (" + innerShapeA + ") and (" + + (innerShapeB + ") of NDArrays with shapes " + a.shape + " and ") + + (b.shape + " and orientations " + MatrixOrientation[aOrientation]) + + (" and " + MatrixOrientation[bOrientation] + " must match.")); + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + }; + NDArrayMath.prototype.vectorTimesMatrix = function (v, matrix) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: first input must be rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: second input must be rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[0], "Error in vectorTimesMatrix: size of first rank 1 input (" + v.size + ") " + + "must match inner dimension of second rank 2 input, but got " + + ("rank " + matrix.rank + ".")); + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + }; + NDArrayMath.prototype.matrixTimesVector = function (matrix, v) { + util.assert(v.rank === 1, "Error in vectorTimesMatrix: second input must rank 1, but got " + + ("rank " + v.rank + ".")); + util.assert(matrix.rank === 2, "Error in vectorTimesMatrix: first input must be a rank 2, but got " + + ("rank " + matrix.rank + ".")); + util.assert(v.size === matrix.shape[1], "Error in vectorTimesMatrix: size of first rank 1 input " + v.size + " " + + "must match inner dimension of second rank 2 input, but got " + + ("shape " + matrix.shape + ".")); + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + }; + NDArrayMath.prototype.dotProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in dotProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + util.assert(v1.size === v2.size, "Error in dotProduct: size of inputs (" + v1.size + ") and (" + + (v2.size + ") must match.")); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + }; + NDArrayMath.prototype.outerProduct = function (v1, v2) { + util.assert(v1.rank === 1 && v2.rank === 1, "Error in outerProduct: inputs must be rank 1, but got ranks " + + (v1.rank + " and " + v2.rank + ".")); + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + }; + NDArrayMath.prototype.clone = function (ndarray) { + return this.track(this.cloneInternal(ndarray)); + }; + NDArrayMath.prototype.reshape = function (ndarray, newShape) { + util.assert(ndarray.size === util.sizeFromShape(newShape), "Error in reshape: old size " + ndarray.size + " must match new size " + + (util.sizeFromShape(newShape) + ".")); + return this.track(this.reshapeInternal(ndarray, newShape)); + }; + NDArrayMath.prototype.slice2D = function (input, begin, size) { + util.assert(begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], "Error in slice2D: requested start position " + begin + " and size " + + (size + " would overflow input of shape " + input.shape + ".")); + return this.track(this.slice2DInternal(input, begin, size)); + }; + NDArrayMath.prototype.copy2D = function (source, sourceBegin, sourceSize, dest, destBegin, destSize) { + util.assert(sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], "Error in copy2D: requested source start position " + sourceBegin + " " + + ("and source size " + sourceSize + " would overflow source NDArray") + + ("of shape " + source.shape + ".")); + util.assert(destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], "Error in copy2D: requested dest start position " + destBegin + " " + + ("and source size " + destSize + " would overflow dest NDArray of") + + ("shape " + dest.shape + ".")); + copy2d_util.validateShapes(sourceSize, destSize); + return this.copy2DInternal(source, sourceBegin, sourceSize, dest, destBegin, destSize); + }; + NDArrayMath.prototype.concat3D = function (ndarray1, ndarray2, axis) { + concat3d_util.assertConcat3DShapesMatch(ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + }; + NDArrayMath.prototype.logSumExp = function (ndarray) { + return this.track(this.logSumExpInternal(ndarray)); + }; + NDArrayMath.prototype.sum = function (ndarray) { + return this.track(this.sumInternal(ndarray)); + }; + NDArrayMath.prototype.argMin = function (ndarray) { + return this.track(this.argMinInternal(ndarray)); + }; + NDArrayMath.prototype.argMax = function (ndarray) { + return this.track(this.argMaxInternal(ndarray)); + }; + NDArrayMath.prototype.argMaxEquals = function (x1, x2) { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + }; + NDArrayMath.prototype.topK = function (ndarray, k) { + util.assert(k <= ndarray.size, "Error in topK: k value (" + k + ") must be less than size of input " + + ("ndarray, got shape " + ndarray.shape + ".")); + var result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + }; + NDArrayMath.prototype.min = function (ndarray) { + return this.track(this.minInternal(ndarray)); + }; + NDArrayMath.prototype.max = function (ndarray) { + return this.track(this.maxInternal(ndarray)); + }; + NDArrayMath.prototype.softmax = function (x) { + var _this = this; + return this.scope(function () { + var lse = _this.logSumExp(x); + var logResult = _this.arrayMinusScalar(x, lse); + return _this.exp(logResult); + }); + }; + NDArrayMath.prototype.switchDim = function (a, newDim) { + util.assert(a.rank === newDim.length, "Error in switchDim: length of input shape " + a.shape + " " + + ("must match size of newDim array " + newDim + ".")); + return this.track(this.switchDimInternal(a, newDim)); + }; + NDArrayMath.prototype.scalarPlusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarPlusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarPlusArrayInternal(c, a)); + }; + NDArrayMath.prototype.scalarMinusArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarMinusArray: first argument must be rank 0, but got " + + ("rank " + c.rank + ".")); + return this.track(this.scalarMinusArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayMinusScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayMinusScalar: second argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.arrayMinusScalarInternal(a, c)); + }; + NDArrayMath.prototype.neg = function (a) { + return this.track(this.negInternal(a)); + }; + NDArrayMath.prototype.add = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + }; + NDArrayMath.prototype.sub = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + }; + NDArrayMath.prototype.elementWiseMul = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + }; + NDArrayMath.prototype.divide = function (a, b) { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + }; + NDArrayMath.prototype.scalarDividedByArray = function (c, a) { + util.assert(c.size === 1, "Error in scalarDividedByArray: first argument must be rank 0, but " + + ("got NDArray of rank " + c.rank + ".")); + return this.track(this.scalarDividedByArrayInternal(c, a)); + }; + NDArrayMath.prototype.arrayDividedByScalar = function (a, c) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: second argument must be rank 0, " + + ("but got NDArray of rank " + c.rank + ".")); + return this.track(this.arrayDividedByScalarInternal(a, c)); + }; + NDArrayMath.prototype.exp = function (ndarray) { + return this.track(this.expInternal(ndarray)); + }; + NDArrayMath.prototype.log = function (ndarray) { + return this.track(this.logInternal(ndarray)); + }; + NDArrayMath.prototype.relu = function (ndarray) { + return this.track(this.reluInternal(ndarray)); + }; + NDArrayMath.prototype.sigmoid = function (ndarray) { + return this.track(this.sigmoidInternal(ndarray)); + }; + NDArrayMath.prototype.tanh = function (ndarray) { + return this.track(this.tanhInternal(ndarray)); + }; + NDArrayMath.prototype.sin = function (ndarray) { + return this.track(this.sinInternal(ndarray)); + }; + NDArrayMath.prototype.step = function (ndarray) { + return this.track(this.stepInternal(ndarray)); + }; + NDArrayMath.prototype.scaledArrayAdd = function (c1, a, c2, b) { + util.assert(c1.size === 1, "Error in scaledArrayAdd: first argument must rank 0, but got " + + (" rank " + c1.rank + ".")); + util.assert(c2.size === 1, "Error in scaledArrayAdd: third argument must be rank 0, but got " + + ("NDArray of rank " + c2.rank + ".")); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + }; + NDArrayMath.prototype.scalarTimesArray = function (c, a) { + util.assert(c.size === 1, "Error in arrayDividedByScalar: first argument must be rank 0, but " + + ("got rank " + c.rank + ".")); + return this.track(this.scalarTimesArrayInternal(c, a)); + }; + NDArrayMath.prototype.elementWiseMulBroadcast = function (a, b) { + util.assert(a.rank === 2, "Error in elementWiseMulBroadcast: first argument must be " + + ("rank 2, but got rank " + a.rank + ".")); + util.assert(b.rank === 2, "Error in elementWiseMulBroadcast: second argument must be " + + ("rank 2, but got rank " + b.rank + ".")); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + }; + NDArrayMath.prototype.conv2d = function (x, weights, biases, stride, zeroPad) { + util.assert(x.rank === 3, "Error in conv2d: x must be rank 3, but got rank " + x.rank + "."); + util.assert(weights.rank === 4, "Error in conv2d: weights must be rank 4, but got rank " + + (weights.rank + ".")); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2d: biases must be rank 1, but got rank " + + (biases.rank + ".")); + } + util.assert(x.shape[2] === weights.shape[2], "Error in conv2d: depth of input (" + x.shape[2] + ") must match " + + ("input depth for weights " + weights.shape[2] + ".")); + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + }; + NDArrayMath.prototype.conv2dBackProp = function (x, dy, weights, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dBackProp: x must be rank 3, but got shape " + + (x.shape + ".")); + util.assert(dy.rank === 3, "Error in conv2dBackProp: dy must be rank 3, but got shape " + + (dy.shape + ".")); + util.assert(weights.rank === 4, "Error in conv2dBackProp: weights must be rank 4, but got shape " + + (weights.shape + ".")); + util.assert(x.shape[2] === weights.shape[2], "Error in conv2dBackProp: depth of x " + x.shape[2] + ") must " + + ("match input depth for weights (" + weights.shape[2] + ".")); + util.assert(dy.shape[2] === weights.shape[3], "Error in conv2dBackProp: depth of dy (" + dy.shape[2] + ") must " + + ("match output depth for weights (" + weights.shape[3] + ").")); + var backpropResult = this.conv2dBackPropInternal(x, dy, weights, stride, pad); + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + return backpropResult; + }; + NDArrayMath.prototype.conv2dTranspose = function (x, weights, biases, stride, pad) { + util.assert(x.rank === 3, "Error in conv2dTranspose: x must be rank 3, but got rank " + + (x.rank + ".")); + util.assert(weights.rank === 4, "Error in conv2dTranspose: weights must be rank 4, but got " + + ("rank " + weights.rank)); + if (biases != null) { + util.assert(biases.rank === 1, "Error in conv2dTranspose: biases must be rank 1, but got ' +\n 'rank " + biases.rank + "."); + } + util.assert(x.shape[2] === weights.shape[3], "Error in conv2dTranspose: depth of input (" + x.shape[2] + ") must " + + ("match input depth for weights " + weights.shape[3] + ".")); + return this.track(this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + }; + NDArrayMath.prototype.maxPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.maxPoolBackprop = function (dy, x, fSize, stride, pad) { + util.assert(dy.rank === 3, "Error in maxPoolBackprop: dy must be rank 3 but got rank " + + (dy.rank + ".")); + util.assert(x.rank === 3, "Error in maxPoolBackprop: x must be rank 3 but got rank " + + (x.rank + ".")); + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + }; + NDArrayMath.prototype.minPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in minPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.avgPool = function (x, fSize, stride, pad) { + util.assert(x.rank === 3, "Error in avgPool: x must be rank 3 but got rank " + x.rank + "."); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + }; + NDArrayMath.prototype.resizeBilinear3D = function (x, newShape2D, alignCorners) { + if (alignCorners === void 0) { alignCorners = false; } + util.assert(x.rank === 3, "Error in resizeBilinear3D: x must be rank 3 but got rank " + x.rank + "."); + util.assert(newShape2D.length === 2, "Error in resizeBilinear3D: new shape must 2D, but got shape " + + (newShape2D + ".")); + return this.track(this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + }; + NDArrayMath.prototype.batchNormalization3D = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + util.assert(x.rank === 3, "Error in batchNormalization3D: x must be rank 3 but got rank " + + (x.rank + ".")); + util.assert(mean.rank === 3 || mean.rank === 1, "Error in batchNormalization3D: mean must be rank 3 or rank 1 but " + + ("got rank " + mean.rank + ".")); + util.assert(variance.rank === 3 || variance.rank === 1, "Error in batchNormalization3D: variance must be rank 3 or rank 1 " + + ("but got rank " + variance.rank + ".")); + if (scale != null) { + util.assert(scale.rank === 3 || scale.rank === 1, "Error in batchNormalization3D: scale must be rank 3 or rank 1 " + + ("but got rank " + scale.rank + ".")); + } + if (offset != null) { + util.assert(offset.rank === 3 || offset.rank === 1, "Error in batchNormalization3D: offset must be rank 3 or rank 1 " + + ("but got rank " + offset.rank + ".")); + } + return this.track(this.batchNormalization3DInternal(x, mean, variance, varianceEpsilon, scale, offset)); + }; + return NDArrayMath; +}()); +exports.NDArrayMath = NDArrayMath; +var MatrixOrientation; +(function (MatrixOrientation) { + MatrixOrientation[MatrixOrientation["REGULAR"] = 0] = "REGULAR"; + MatrixOrientation[MatrixOrientation["TRANSPOSED"] = 1] = "TRANSPOSED"; +})(MatrixOrientation = exports.MatrixOrientation || (exports.MatrixOrientation = {})); + +},{"../util":87,"./concat3d_util":16,"./copy2d_util":18,"./ndarray":23}],21:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var copy2D_util = require("./copy2d_util"); +var math_1 = require("./math"); +var ndarray_1 = require("./ndarray"); +var NDArrayMathCPU = (function (_super) { + __extends(NDArrayMathCPU, _super); + function NDArrayMathCPU(safeMode) { + if (safeMode === void 0) { safeMode = false; } + return _super.call(this, safeMode) || this; + } + NDArrayMathCPU.prototype.cloneInternal = function (ndarray) { + return ndarray_1.NDArray.make(ndarray.shape, { values: new Float32Array(ndarray.getValues()) }); + }; + NDArrayMathCPU.prototype.reshapeInternal = function (ndarray, newShape) { + return this.cloneInternal(ndarray).reshape(newShape); + }; + NDArrayMathCPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.Array2D.zeros(sizeRowCol); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathCPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + var srcValues = source.getValues(); + var dstValues = dest.getValues(); + var n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (var i = 0; i < n; ++i) { + var srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + var srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + var srcOff = srcRow * source.shape[1] + srcCol; + var dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + var dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + var dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + }; + NDArrayMathCPU.prototype.concat3DInternal = function (x1, x2, axis) { + var outputShape = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var values = ndarray_1.NDArray.zeros(outputShape); + for (var i = 0; i < outputShape[0]; i++) { + for (var j = 0; j < outputShape[1]; j++) { + for (var k = 0; k < outputShape[2]; k++) { + var index = [i, j, k]; + var value = void 0; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } + else { + index[axis] -= x1.shape[axis]; + var i2 = index[0], j2 = index[1], k2 = index[2]; + value = x2.get(i2, j2, k2); + } + values.set(value, i, j, k); + } + } + } + return values; + }; + NDArrayMathCPU.prototype.scalarPlusArrayInternal = function (c, a) { + var resultValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + var c1Val = c1.get(); + var c2Val = c2.get(); + for (var i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: cValues }); + }; + NDArrayMathCPU.prototype.scalarTimesArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cVal = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarMinusArrayInternal = function (c, a) { + var negA = this.negInternal(a); + var result = this.scalarPlusArrayInternal(c, negA); + negA.dispose(); + return result; + }; + NDArrayMathCPU.prototype.arrayMinusScalarInternal = function (a, c) { + var negC = this.negInternal(c); + var result = this.scalarPlusArrayInternal(negC, a); + negC.dispose(); + return result; + }; + NDArrayMathCPU.prototype.negInternal = function (a) { + return this.scalarTimesArrayInternal(ndarray_1.Scalar.NEG_ONE, a); + }; + NDArrayMathCPU.prototype.addInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.ONE, b); + }; + NDArrayMathCPU.prototype.subInternal = function (a, b) { + return this.scaledArrayAddInternal(ndarray_1.Scalar.ONE, a, ndarray_1.Scalar.NEG_ONE, b); + }; + NDArrayMathCPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var leftDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var rightDim = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var normalGetter = function (matrix, i, j) { + return matrix.get(i, j); + }; + var transposedGetter = function (matrix, i, j) { + return matrix.get(j, i); + }; + var aGetter = (aOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var bGetter = (bOrientation === math_1.MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + var values = new Float32Array(leftDim * rightDim); + var index = 0; + for (var i = 0; i < leftDim; ++i) { + for (var j = 0; j < rightDim; ++j) { + var sum = 0; + for (var k = 0; k < sharedDim; ++k) { + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return ndarray_1.Array2D.new([leftDim, rightDim], values); + }; + NDArrayMathCPU.prototype.elementWiseMulInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + var maxRow = Math.max(a.shape[0], b.shape[0]); + var maxCol = Math.max(a.shape[1], b.shape[1]); + var values = new Float32Array(maxRow * maxCol); + var index = 0; + for (var row = 0; row < maxRow; row++) { + for (var col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return ndarray_1.Array2D.new([maxRow, maxCol], values); + }; + NDArrayMathCPU.prototype.divideInternal = function (a, b) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var bValues = b.getValues(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.scalarDividedByArrayInternal = function (c, a) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.arrayDividedByScalarInternal = function (a, c) { + var newValues = new Float32Array(a.size); + var aValues = a.getValues(); + var cValue = c.get(); + for (var i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return ndarray_1.NDArray.make(a.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.sumInternal = function (ndarray) { + var sum = 0; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + sum += values[i]; + } + return ndarray_1.Scalar.new(sum); + }; + NDArrayMathCPU.prototype.argMinInternal = function (ndarray) { + var min = Number.MAX_VALUE; + var minIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return ndarray_1.Scalar.new(minIndex); + }; + NDArrayMathCPU.prototype.argMaxInternal = function (ndarray) { + var max = Number.NEGATIVE_INFINITY; + var maxIndex = -1; + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return ndarray_1.Scalar.new(maxIndex); + }; + NDArrayMathCPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var argMax1 = this.argMaxInternal(x1).get(); + var argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return ndarray_1.Scalar.new(NaN); + } + return ndarray_1.Scalar.new(+(argMax1 === argMax2)); + }; + NDArrayMathCPU.prototype.topKInternal = function (ndarray, k) { + var values = ndarray.getValues(); + var valuesAndIndices = []; + for (var i = 0; i < values.length; i++) { + valuesAndIndices.push({ value: values[i], index: i }); + } + valuesAndIndices.sort(function (a, b) { + return b.value - a.value; + }); + var topkValues = new Float32Array(k); + var topkIndices = new Float32Array(k); + for (var i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return { values: ndarray_1.Array1D.new(topkValues), indices: ndarray_1.Array1D.new(topkIndices) }; + }; + NDArrayMathCPU.prototype.minInternal = function (ndarray) { + var values = ndarray.getValues(); + var min = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return ndarray_1.Scalar.new(min); + }; + NDArrayMathCPU.prototype.maxInternal = function (ndarray) { + var values = ndarray.getValues(); + var max = values[0]; + for (var i = 1; i < values.length; ++i) { + var value = values[i]; + if (isNaN(value)) { + return ndarray_1.Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return ndarray_1.Scalar.new(max); + }; + NDArrayMathCPU.prototype.expInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logInternal = function (ndarray) { + var values = ndarray.getValues(); + var newValues = new Float32Array(values.length); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + newValues[i] = Math.log(value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: newValues }); + }; + NDArrayMathCPU.prototype.logSumExpInternal = function (ndarray) { + var xMax = this.max(ndarray); + var a = this.arrayMinusScalar(ndarray, xMax); + var b = this.exp(a); + var c = this.sum(b); + var d = this.log(c); + var result = this.add(xMax, d); + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + return result; + }; + NDArrayMathCPU.prototype.reluInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sigmoidInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.tanhInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.sinInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.stepInternal = function (ndarray) { + var resultValues = new Float32Array(ndarray.size); + var values = ndarray.getValues(); + for (var i = 0; i < values.length; ++i) { + var value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return ndarray_1.NDArray.make(ndarray.shape, { values: resultValues }); + }; + NDArrayMathCPU.prototype.conv2dInternal = function (x, weights, biases, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], inputDepth = _a[2]; + var fieldSize = weights.shape[0]; + var outputDepth = weights.shape[3]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < outputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fieldSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fieldSize + xCCorner); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + for (var d1 = 0; d1 < inputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + var bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathCPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var fSize = weights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR - pad; + var xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + var xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC - pad; + var xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + var xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + var dotProd = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR * origStride - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC * origStride - xCCorner; + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + var bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dTransposeShaderLike = function (x, origWeights, origStride, origPad) { + var fSize = origWeights.shape[0]; + var pad = fSize - 1 - origPad; + var origInputDepth = origWeights.shape[2]; + var origOutputDepth = origWeights.shape[3]; + var _a = x.shape, xRows = _a[0], xCols = _a[1], xDepth = _a[2]; + var xRowsDilated = (xRows - 1) * origStride + 1; + var xColsDilated = (xCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d2 = 0; d2 < origInputDepth; ++d2) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xRCorner = yR - pad; + var xCCorner = yC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (var d1 = 0; d1 < origOutputDepth; ++d1) { + var pixel = x.get(xR, xC, d1); + var weight = origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + var dW = ndarray_1.Array4D.zeros(weightsShape); + var yNumRows = dY.shape[0]; + var yNumCols = dY.shape[1]; + var xNumRows = x.shape[0]; + var xNumCols = x.shape[1]; + for (var wR = 0; wR < fSize; ++wR) { + var yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + var yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + for (var wC = 0; wC < fSize; ++wC) { + var yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + var yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + for (var d1 = 0; d1 < inputDepth; ++d1) { + for (var d2 = 0; d2 < outputDepth; ++d2) { + var dotProd = 0; + for (var yR = yRMin; yR < yRMax; ++yR) { + var xR = wR + yR * stride - zeroPad; + for (var yC = yCMin; yC < yCMax; ++yC) { + var xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + }; + NDArrayMathCPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var numRows = dY.shape[0]; + var numCols = dY.shape[1]; + var values = new Float32Array(outputDepth); + for (var d2 = 0; d2 < outputDepth; ++d2) { + var sum = 0; + for (var r = 0; r < numRows; ++r) { + for (var c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return ndarray_1.Array1D.new(values); + }; + NDArrayMathCPU.prototype.switchDimInternal = function (t, newDim) { + var newShape = new Array(t.rank); + for (var i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + var resultValues = new Float32Array(t.size); + var values = t.getValues(); + var result = ndarray_1.NDArray.make(newShape, { values: resultValues }); + for (var i = 0; i < t.size; ++i) { + var loc = t.indexToLoc(i); + var newLoc = new Array(loc.length); + for (var i_1 = 0; i_1 < newLoc.length; i_1++) { + newLoc[i_1] = loc[newDim[i_1]]; + } + var newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + }; + NDArrayMathCPU.prototype.pool = function (x, fSize, stride, pad, poolType) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D([xRows, xCols, depth], fSize, depth, stride, pad); + var y = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < y.shape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < y.shape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var minMaxValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + var avgValue = 0; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } + else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + }; + NDArrayMathCPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'max'); + }; + NDArrayMathCPU.prototype.maxPoolPositions = function (x, fSize, stride, pad) { + var _a = x.shape, xRows = _a[0], xCols = _a[1], depth = _a[2]; + var outputShape = conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + var maxPositions = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var yR = 0; yR < outputShape[0]; ++yR) { + var xRCorner = yR * stride - pad; + var xRMin = Math.max(0, xRCorner); + var xRMax = Math.min(xRows, fSize + xRCorner); + for (var yC = 0; yC < outputShape[1]; ++yC) { + var xCCorner = yC * stride - pad; + var xCMin = Math.max(0, xCCorner); + var xCMax = Math.min(xCols, fSize + xCCorner); + var maxValue = Number.NEGATIVE_INFINITY; + var maxPosition = -1; + for (var xR = xRMin; xR < xRMax; ++xR) { + var wR = xR - xRCorner; + for (var xC = xCMin; xC < xCMax; ++xC) { + var wC = xC - xCCorner; + var pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + }; + NDArrayMathCPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + var pad = fSize - 1 - origPad; + var _a = dy.shape, dyRows = _a[0], dyCols = _a[1], depth = _a[2]; + var dyRowsDilated = (dyRows - 1) * origStride + 1; + var dxColsDilated = (dyCols - 1) * origStride + 1; + var outputShape = conv_util.computeOutputShape3D([dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + var dx = ndarray_1.Array3D.zeros(outputShape); + for (var d = 0; d < depth; ++d) { + for (var dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (var dxC = 0; dxC < dx.shape[1]; ++dxC) { + var dyRCorner = dxR - pad; + var dyCCorner = dxC - pad; + var dotProd = 0; + for (var wR = 0; wR < fSize; ++wR) { + var dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (var wC = 0; wC < fSize; ++wC) { + var dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + var maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + var curPos = wR * fSize + wC; + var mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + var pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + }; + NDArrayMathCPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'min'); + }; + NDArrayMathCPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + return this.pool(x, fSize, stride, pad, 'avg'); + }; + NDArrayMathCPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var output = ndarray_1.Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + var effectiveInputSize = alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + var effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (var r = 0; r < output.shape[0]; r++) { + for (var c = 0; c < output.shape[1]; c++) { + for (var d = 0; d < output.shape[2]; d++) { + var sourceFracRow = (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + var sourceFracCol = (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + var sourceRowFloor = Math.floor(sourceFracRow); + var sourceRowCeil = Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + var sourceColFloor = Math.floor(sourceFracCol); + var sourceColCeil = Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + var topLeft = x.get(sourceRowFloor, sourceColFloor, d); + var bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + var topRight = x.get(sourceRowFloor, sourceColCeil, d); + var bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + var rowFrac = sourceFracRow - sourceRowFloor; + var colFrac = sourceFracCol - sourceColFloor; + var top_1 = topLeft + (topRight - topLeft) * colFrac; + var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + var newValue = top_1 + (bottom - top_1) * rowFrac; + output.set(newValue, r, c, d); + } + } + } + return output; + }; + NDArrayMathCPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + if (varianceEpsilon === void 0) { varianceEpsilon = .001; } + var xValues = x.getValues(); + var meanValues = mean.getValues(); + var varianceValues = variance.getValues(); + var scaleValues = scale ? scale.getValues() : new Float32Array([1]); + var offsetValues = offset ? offset.getValues() : new Float32Array([0]); + var outValues = new Float32Array(xValues.length); + for (var i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt(varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return ndarray_1.NDArray.make(x.shape, { values: outValues }); + }; + return NDArrayMathCPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathCPU = NDArrayMathCPU; + +},{"../math/conv_util":17,"../util":87,"./concat3d_util":16,"./copy2d_util":18,"./math":20,"./ndarray":23}],22:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var concat3d_util = require("./concat3d_util"); +var conv_util = require("./conv_util"); +var math_1 = require("./math"); +var ndarray = require("./ndarray"); +var ndarray_1 = require("./ndarray"); +var addscaledmat_gpu = require("./webgl/addscaledmat_gpu"); +var addsubmuldiv_gpu = require("./webgl/addsubmuldiv_gpu"); +var addsubmuldiv_gpu_1 = require("./webgl/addsubmuldiv_gpu"); +var argmaxequals_gpu = require("./webgl/argmaxequals_gpu"); +var argminmax_gpu = require("./webgl/argminmax_gpu"); +var avg_pool_gpu = require("./webgl/avg_pool_gpu"); +var batchnorm_gpu = require("./webgl/batchnorm_gpu"); +var concat3d_gpu = require("./webgl/concat3d_gpu"); +var conv_backprop_gpu = require("./webgl/conv_backprop_gpu"); +var conv_gpu = require("./webgl/conv_gpu"); +var copy_gpu = require("./webgl/copy_gpu"); +var exp_gpu = require("./webgl/exp_gpu"); +var gpgpu_context_1 = require("./webgl/gpgpu_context"); +var gpgpu_util = require("./webgl/gpgpu_util"); +var log_gpu = require("./webgl/log_gpu"); +var logsumexp_gpu = require("./webgl/logsumexp_gpu"); +var max_pool_backprop_gpu = require("./webgl/max_pool_backprop_gpu"); +var max_pool_gpu = require("./webgl/max_pool_gpu"); +var min_pool_gpu = require("./webgl/min_pool_gpu"); +var minmax_gpu = require("./webgl/minmax_gpu"); +var mulmat_gpu = require("./webgl/mulmat_gpu"); +var neg_gpu = require("./webgl/neg_gpu"); +var pool_gpu = require("./webgl/pool_gpu"); +var reducesum_gpu = require("./webgl/reducesum_gpu"); +var relu_gpu = require("./webgl/relu_gpu"); +var reshape_gpu = require("./webgl/reshape_gpu"); +var resize_bilinear_gpu = require("./webgl/resize_bilinear_gpu"); +var shader_compiler = require("./webgl/shader_compiler"); +var sigmoid_gpu = require("./webgl/sigmoid_gpu"); +var step_gpu = require("./webgl/step_gpu"); +var texture_manager_1 = require("./webgl/texture_manager"); +var trig_gpu = require("./webgl/trig_gpu"); +var webgl_util = require("./webgl/webgl_util"); +var ARGMAX_PROG = 'argmax'; +var ARGMAX_EQUALS_PROG = 'argmaxequals'; +var ARGMIN_PROG = 'argmin'; +var BATCHNORM_PROG = 'batchnorm'; +var COPY_PROG = 'copy'; +var CONCAT_PROG = 'concat'; +var ADD_SCALED_MAT_PROG = 'addscaledmat'; +var MATMUL_PROG = 'matmul'; +var RELU_PROG = 'relu'; +var TANH_PROG = 'tanh'; +var SIN_PROG = 'sin'; +var SIGMOID_PROG = 'sigmoid'; +var MAX_PROG = 'max'; +var MIN_PROG = 'min'; +var NEG_PROG = 'neg'; +var EXP_PROG = 'exp'; +var LOG_PROG = 'log'; +var SUM_PROG = 'sum'; +var STEP_PROG = 'step'; +var LOGSUMEXP_PROG = 'logsumexp'; +var RESHAPE_PROG = 'reshape'; +var ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; +var CONV2D_PROG = 'conv'; +var CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +var CONV2D_DERW_PROG = 'conv_derw'; +var CONV2D_DERB_PROG = 'conv_derb'; +var MAX_POOL_PROG = 'maxpool'; +var MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +var MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +var MIN_POOL_PROG = 'minpool'; +var AVG_POOL_PROG = 'avgpool'; +var RESIZE_BILINEAR_PROG = 'resizebilin'; +function makeCopyProgramName(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + var shapeName = sourceShapeRowCol[0] + "_" + sourceShapeRowCol[1]; + var srcSizeName = sourceSizeRowCol[0] + "_" + sourceSizeRowCol[1]; + var dstSizeName = destSizeRowCol[0] + "_" + destSizeRowCol[1]; + return COPY_PROG + "_" + shapeName + "_" + srcSizeName + "_" + dstSizeName; +} +var NDArrayMathGPU = (function (_super) { + __extends(NDArrayMathGPU, _super); + function NDArrayMathGPU(gpgpu, safeMode) { + if (safeMode === void 0) { safeMode = true; } + var _this = _super.call(this, safeMode) || this; + _this.programCache = {}; + if (gpgpu == null) { + var gl = gpgpu_util.createWebGLContext(); + _this.gpgpu = new gpgpu_context_1.GPGPUContext(gl); + _this.gpgpuCreatedLocally = true; + } + else { + _this.gpgpu = gpgpu; + _this.gpgpuCreatedLocally = false; + } + _this.textureManager = new texture_manager_1.TextureManager(_this.gpgpu); + ndarray.initializeGPU(_this.gpgpu, _this.textureManager); + return _this; + } + NDArrayMathGPU.prototype.getGPGPUContext = function () { + return this.gpgpu; + }; + NDArrayMathGPU.prototype.cloneInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), function () { return copy_gpu.getFragmentShaderSource(textureShapeRC, textureShapeRC, textureShapeRC); }); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + copy_gpu.copy(this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeInternal = function (ndarray, newShape) { + var newTexShape; + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error("Reshapes into " + newShape.length + "-dim ndarray is not yet " + + "supported on GPU"); + } + var actualTexShape = ndarray.getTextureShapeRC(newTexShape); + var clonedArray; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } + else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + }; + NDArrayMathGPU.prototype.slice2DInternal = function (input, beginRowCol, sizeRowCol) { + var result = ndarray_1.NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal(input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + }; + NDArrayMathGPU.prototype.copy2DInternal = function (source, sourceBeginRowCol, sourceSizeRowCol, dest, destBeginRowCol, destSizeRowCol) { + var sourceShapeRC = source.getTextureShapeRC(); + var destShapeRC = dest.getTextureShapeRC(); + var program = this.getAndSaveProgram(makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), function () { return copy_gpu.getFragmentShaderSource(sourceShapeRC, sourceSizeRowCol, destSizeRowCol); }); + copy_gpu.copy(this.gpgpu, program, source.getTexture(), sourceShapeRC, sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, destBeginRowCol, destSizeRowCol); + }; + NDArrayMathGPU.prototype.concat3DInternal = function (x1, x2, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1.shape); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2.shape); + var actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + var cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + var actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + var cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + var resultShapeRCD = concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + var program = this.getAndSaveProgram(CONCAT_PROG + "_" + x1.shape + "_" + x2.shape + "_" + axis, function () { return concat3d_gpu.getFragmentShaderSource(x1.shape, x2.shape, resultShapeRCD, axis); }); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + concat3d_gpu.concat3D(this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, resultTexShape); + if (cleanupX1) { + x1.dispose(); + } + if (cleanupX2) { + x2.dispose(); + } + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.scalarPlusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayMinusScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.scalarMinusArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scaledArrayAddInternal = function (c1, a, c2, b) { + var cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + var program = this.getAndSaveProgram(ADD_SCALED_MAT_PROG, function () { return addscaledmat_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + addscaledmat_gpu.addScaledMatrices(this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.scalarTimesArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.negInternal = function (a) { + var program = this.getAndSaveProgram(NEG_PROG, function () { return neg_gpu.getFragmentShaderSource(); }); + var textureShapeRC = a.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + neg_gpu.neg(this.gpgpu, program, a.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reshapeTexture = function (a, newTextureShape) { + var aTexShape = a.getTextureShapeRC(); + var program = this.getAndSaveProgram(RESHAPE_PROG, function () { return reshape_gpu.getFragmentShaderSource(); }); + var resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape(this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], resultTexture, newTextureShape[0], newTextureShape[1]); + return ndarray_1.NDArray.make(a.shape, { texture: resultTexture, textureShapeRC: newTextureShape }); + }; + NDArrayMathGPU.prototype.matMulInternal = function (a, b, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + var outerShapeA = (aOrientation === math_1.MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + var outerShapeB = (bOrientation === math_1.MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + var outShape = [outerShapeA, outerShapeB]; + var outTexShape = webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + var outTexture = this.textureManager.acquireTexture(outTexShape); + var out = new ndarray_1.Array2D(outShape, { texture: outTexture, textureShapeRC: outTexShape }); + var key = shader_compiler.makeShaderKey([a, b], out); + var program = this.getAndSaveProgram(MATMUL_PROG + "_" + key + "_" + aOrientation + "_" + bOrientation, function () { return mulmat_gpu.getFragmentShader(a, b, out, aOrientation, bOrientation); }); + mulmat_gpu.multiplyMatrix(this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, outTexShape); + return out; + }; + NDArrayMathGPU.prototype.elementWiseMulInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '*', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.elementWiseMulBroadcastInternal = function (a, b) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.batchNormalization3DInternal = function (x, mean, variance, varianceEpsilon, scale, offset) { + var xTexShape = x.getTextureShapeRC(); + var cleanupMean = false; + var preferredMeanTexShape = mean.rank === 1 ? [1, mean.size] : xTexShape; + var meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + var cleanupVariance = false; + var preferredVarianceTexShape = variance.rank === 1 ? [1, variance.size] : xTexShape; + var varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + var scaleTexShape = null; + var cleanupScale = false; + if (scale != null) { + var preferredScaleTexShape = scale.rank === 1 ? [1, scale.size] : xTexShape; + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + var offsetTexShape = null; + var cleanupOffset = false; + if (offset != null) { + var preferredOffsetTexShape = offset.rank === 1 ? [1, offset.size] : xTexShape; + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + var resultTexShape = x.getTextureShapeRC(); + var program = this.getAndSaveProgram(BATCHNORM_PROG + "_" + xTexShape + "_" + meanTexShape + "_" + varianceTexShape + "_" + + (scaleTexShape + "_" + offsetTexShape + "_" + varianceEpsilon), function () { return batchnorm_gpu.getFragmentShaderSource(xTexShape, meanTexShape, varianceTexShape, offsetTexShape, scaleTexShape, varianceEpsilon); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + batchnorm_gpu.batchNormalization(this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), meanTexShape, variance.getTexture(), varianceTexShape, offset != null ? offset.getTexture() : null, offset != null ? offsetTexShape : null, scale != null ? scale.getTexture() : null, scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale.dispose(); + } + if (cleanupOffset) { + offset.dispose(); + } + return ndarray_1.NDArray.make(x.shape, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.switchDimInternal = function (a, newDim) { + throw new Error('Not yet implemented!'); + }; + NDArrayMathGPU.prototype.sumInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(SUM_PROG + "_" + numRows + "_" + numColumns, function () { return reducesum_gpu.getFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMinInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMIN_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_PROG + "_" + numRows + "_" + numColumns, function () { return argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argminmax_gpu.argMinMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.argMaxEqualsInternal = function (x1, x2) { + var actualX1TexShape = x1.getTextureShapeRC(); + var actualX2TexShape = x2.getTextureShapeRC(); + var cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + var textureShapeRC = x1.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(ARGMAX_EQUALS_PROG + "_" + numRows + "_" + numColumns, function () { return argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + argmaxequals_gpu.argMaxEquals(this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, numColumns, resultTexture); + if (cleanupX2) { + x2.dispose(); + } + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.topKInternal = function (ndarray, k) { + throw new Error('topK GPU not yet implemented!'); + }; + NDArrayMathGPU.prototype.minInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MIN_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMinFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.maxInternal = function (ndarray) { + var textureShapeRC = ndarray.getTextureShapeRC(); + var numRows = textureShapeRC[0], numColumns = textureShapeRC[1]; + var program = this.getAndSaveProgram(MAX_PROG + "_" + numRows + "_" + numColumns, function () { return minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns); }); + var resultTexture = this.textureManager.acquireTexture([1, 1]); + minmax_gpu.minMax(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, resultTexture); + return new ndarray_1.Scalar({ texture: resultTexture }); + }; + NDArrayMathGPU.prototype.divideInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.scalarDividedByArrayInternal = function (c, a) { + return this.addSubMulDiv(c, a, a.shape, addsubmuldiv_gpu_1.OperandType.SCALAR, '/', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.arrayDividedByScalarInternal = function (a, c) { + return this.addSubMulDiv(a, c, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '/', addsubmuldiv_gpu_1.OperandType.SCALAR); + }; + NDArrayMathGPU.prototype.addInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '+', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.subInternal = function (a, b) { + return this.addSubMulDiv(a, b, a.shape, addsubmuldiv_gpu_1.OperandType.MATRIX, '-', addsubmuldiv_gpu_1.OperandType.MATRIX); + }; + NDArrayMathGPU.prototype.logSumExpInternal = function (ndarray) { + var _a = ndarray.getTextureShapeRC(), numRows = _a[0], numColumns = _a[1]; + var program = this.getAndSaveProgram(LOGSUMEXP_PROG + "_" + numRows + "_" + numColumns, function () { return logsumexp_gpu.getFragmentShaderSource(numRows, numColumns); }); + var result = new ndarray_1.Scalar({ texture: this.textureManager.acquireTexture([1, 1]) }); + reducesum_gpu.reduceSum(this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, result.getTexture()); + return result; + }; + NDArrayMathGPU.prototype.expInternal = function (ndarray) { + var program = this.getAndSaveProgram(EXP_PROG, function () { return exp_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + exp_gpu.exp(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.logInternal = function (ndarray) { + var program = this.getAndSaveProgram(LOG_PROG, function () { return log_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.reluInternal = function (ndarray) { + var program = this.getAndSaveProgram(RELU_PROG, function () { return relu_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + relu_gpu.relu(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sigmoidInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIGMOID_PROG, function () { return sigmoid_gpu.getSigmoidFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + sigmoid_gpu.sigmoid(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.tanhInternal = function (ndarray) { + var program = this.getAndSaveProgram(TANH_PROG, function () { return trig_gpu.getTanhFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.tanh(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.sinInternal = function (ndarray) { + var program = this.getAndSaveProgram(SIN_PROG, function () { return trig_gpu.getSinFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + trig_gpu.sin(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.stepInternal = function (ndarray) { + var program = this.getAndSaveProgram(STEP_PROG, function () { return step_gpu.getFragmentShaderSource(); }); + var textureShapeRC = ndarray.getTextureShapeRC(); + var resultTexture = this.textureManager.acquireTexture(textureShapeRC); + step_gpu.step(this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], textureShapeRC[1], resultTexture); + return ndarray_1.NDArray.make(ndarray.shape, { texture: resultTexture, textureShapeRC: textureShapeRC }); + }; + NDArrayMathGPU.prototype.conv2dInternal = function (x, weights, biases, stride, zeroPad) { + var fieldSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_gpu.getFragmentShaderSource(x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fieldSize, outputDepth, stride, zeroPad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_gpu.convolve(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dBackPropInternal = function (x, dy, weights, stride, pad) { + var fSize = weights.shape[0]; + var inputDepth = weights.shape[2]; + var outputDepth = weights.shape[3]; + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var cleanupX = false; + var actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupY = false; + var actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + var dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + var db = this.conv2dDerBias(dy); + var dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return { dx: dx, db: db, dw: dw }; + }; + NDArrayMathGPU.prototype.conv2dTransposeInternal = function (x, weights, biases, origStride, origPad) { + var origInputDepth = weights.shape[2]; + var origOutputDepth = weights.shape[3]; + var fieldSize = weights.shape[0]; + var progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource(x.shape, fieldSize, origInputDepth, origStride, origPad, biases != null); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var wTexShape = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fieldSize); + var biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupW = false; + var actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + var cleanupB = false; + if (biases != null) { + var actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + var dilatedRC = conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + var pad = fieldSize - 1 - origPad; + var resultShape = conv_util.computeOutputShape3D([dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, origInputDepth, 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.convTranspose(this.gpgpu, program, x.getTexture(), weights.getTexture(), biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerWeights = function (x, dY, fSize, stride, zeroPad) { + var inputDepth = x.shape[2]; + var outputDepth = dY.shape[2]; + var progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource(x.shape, fSize, outputDepth, stride, zeroPad); + }); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var yShape = conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride, zeroPad); + var yTexShape = conv_util.computeTexShapeFrom3D(yShape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derWeights(this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + var weightsShape = conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return ndarray_1.NDArray.make(weightsShape, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.conv2dDerBias = function (dY) { + var outputDepth = dY.shape[2]; + var progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + var program = this.getAndSaveProgram(progKey, function () { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + var yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + var cleanupY = false; + var actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + var resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + conv_backprop_gpu.derBias(this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + if (cleanupY) { + dY.dispose(); + } + return ndarray_1.NDArray.make([outputDepth], { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.pool = function (program, x, fSize, stride, pad) { + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + var resultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + var poolResultTex = this.textureManager.acquireTexture(resultTexShape); + pool_gpu.poolCommon(this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + if (cleanupX) { + x.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: poolResultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.maxPoolInternal = function (x, fSize, stride, pad) { + var maxPoolProgKey = [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(maxPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.minPoolInternal = function (x, fSize, stride, pad) { + var minPoolProgKey = [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var minPoolProgram = this.getAndSaveProgram(minPoolProgKey, function () { + return min_pool_gpu.getFragmentShaderMinPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(minPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.avgPoolInternal = function (x, fSize, stride, pad) { + var avgPoolProgKey = [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + var avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, function () { + return avg_pool_gpu.getFragmentShaderAvgPoolSource(x.shape, fSize, stride, pad); + }); + return this.pool(avgPoolProgram, x, fSize, stride, pad); + }; + NDArrayMathGPU.prototype.maxPoolBackpropInternal = function (dy, x, fSize, origStride, origPad) { + var maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + var maxPoolPositionsProgram = this.getAndSaveProgram(maxPoolPositionsProgKey, function () { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource(x.shape, fSize, origStride, origPad); + }); + var maxPoolResultShape = conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], origStride, origPad); + var maxPoolResultTexShape = conv_util.computeTexShapeFrom3D(maxPoolResultShape); + var maxPoolPositionsResultTex = this.textureManager.acquireTexture(maxPoolResultTexShape); + var xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + var actualXTexShape = x.getTextureShapeRC(xTexShape); + var cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + max_pool_gpu.maxPoolCommon(this.gpgpu, maxPoolPositionsProgram, x.getTexture(), maxPoolPositionsResultTex, maxPoolResultTexShape); + var maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + var program = this.getAndSaveProgram(maxPoolBackpropProgKey, function () { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop(dy.shape, fSize, origStride, origPad); + }); + var dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + var actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + var cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + var dilatedDyRC = conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + var pad = fSize - 1 - origPad; + var resultShapeRCD = conv_util.computeOutputShape3D([dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, pad); + var resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + var resultTex = this.textureManager.acquireTexture(resultTexShape); + max_pool_backprop_gpu.maxPoolBackprop(this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, resultTex, resultTexShape); + if (cleanupDy) { + dy.dispose(); + } + if (cleanupX) { + x.dispose(); + } + this.textureManager.releaseTexture(maxPoolPositionsResultTex, maxPoolResultTexShape); + return ndarray_1.NDArray.make(resultShapeRCD, { texture: resultTex, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.resizeBilinear3DInternal = function (x, newShape2D, alignCorners) { + var programKey = [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + var newShapeRCD = [newShape2D[0], newShape2D[1], x.shape[2]]; + var resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + var program = this.getAndSaveProgram(programKey, function () { return resize_bilinear_gpu.getFragmentShaderSource(x.shape, newShape2D, alignCorners); }); + var resultTexture = this.textureManager.acquireTexture(resultTexShape); + resize_bilinear_gpu.resizeBilinear(this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + return ndarray_1.NDArray.make(newShapeRCD, { texture: resultTexture, textureShapeRC: resultTexShape }); + }; + NDArrayMathGPU.prototype.getAndSaveProgram = function (programKey, getShaderSource) { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + }; + NDArrayMathGPU.prototype.addSubMulDiv = function (a, b, resultShape, operandA, opType, operandB) { + var cleanupB = false; + var aOrientation = math_1.MatrixOrientation.REGULAR; + var bOrientation = math_1.MatrixOrientation.REGULAR; + var logicalBTexShape; + if (operandA === addsubmuldiv_gpu_1.OperandType.MATRIX && operandB === addsubmuldiv_gpu_1.OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + var aTexShape_1 = a.getTextureShapeRC(); + var bTexShape_1 = b.getTextureShapeRC(); + logicalBTexShape = bTexShape_1; + if (a.rank === 1) { + if (!util.arraysEqual(bTexShape_1, aTexShape_1)) { + bOrientation = math_1.MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape_1[1], bTexShape_1[0]]; + } + } + if (!util.arraysEqual(aTexShape_1, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape_1); + bOrientation = math_1.MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } + else { + logicalBTexShape = b.getTextureShapeRC(); + } + var aTexShape = a.getTextureShapeRC(); + var bTexShape = b.getTextureShapeRC(); + var programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + var program = this.getAndSaveProgram(programKey, function () { return addsubmuldiv_gpu.getFragmentShaderSource(operandA, aOrientation, opType, operandB, bOrientation); }); + var resultTextureShape = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + var resultTexture = this.textureManager.acquireTexture(resultTextureShape); + addsubmuldiv_gpu.addSubMulDiv(this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), bTexShape, resultTexture, resultTextureShape); + if (cleanupB) { + b.dispose(); + } + return ndarray_1.NDArray.make(resultShape, { texture: resultTexture, textureShapeRC: resultTextureShape }); + }; + NDArrayMathGPU.prototype.doGPUShapesMatch = function (a, b) { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + b.getTextureShapeRC(a.getTextureShapeRC()); + } + else if (b.inGPU()) { + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + }; + NDArrayMathGPU.prototype.getTextureManager = function () { + return this.textureManager; + }; + NDArrayMathGPU.prototype.dispose = function () { + for (var programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + }; + return NDArrayMathGPU; +}(math_1.NDArrayMath)); +exports.NDArrayMathGPU = NDArrayMathGPU; + +},{"../util":87,"./concat3d_util":16,"./conv_util":17,"./math":20,"./ndarray":23,"./webgl/addscaledmat_gpu":24,"./webgl/addsubmuldiv_gpu":25,"./webgl/argmaxequals_gpu":26,"./webgl/argminmax_gpu":27,"./webgl/avg_pool_gpu":28,"./webgl/batchnorm_gpu":29,"./webgl/concat3d_gpu":31,"./webgl/conv_backprop_gpu":32,"./webgl/conv_gpu":33,"./webgl/copy_gpu":34,"./webgl/exp_gpu":35,"./webgl/gpgpu_context":36,"./webgl/gpgpu_util":37,"./webgl/log_gpu":38,"./webgl/logsumexp_gpu":39,"./webgl/max_pool_backprop_gpu":40,"./webgl/max_pool_gpu":41,"./webgl/min_pool_gpu":42,"./webgl/minmax_gpu":43,"./webgl/mulmat_gpu":44,"./webgl/neg_gpu":45,"./webgl/pool_gpu":46,"./webgl/reducesum_gpu":47,"./webgl/relu_gpu":48,"./webgl/reshape_gpu":50,"./webgl/resize_bilinear_gpu":51,"./webgl/shader_compiler":52,"./webgl/sigmoid_gpu":53,"./webgl/step_gpu":54,"./webgl/texture_manager":56,"./webgl/trig_gpu":57,"./webgl/webgl_util":59}],23:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var webgl_util = require("./webgl/webgl_util"); +exports.GPGPU = null; +exports.TEXTURE_MANAGER = null; +function initializeGPU(gpgpu, textureManager) { + exports.GPGPU = gpgpu; + exports.TEXTURE_MANAGER = textureManager; +} +exports.initializeGPU = initializeGPU; +function throwIfGPUNotInitialized() { + if (exports.GPGPU == null || exports.TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} +var NDArray = (function () { + function NDArray(shape, data) { + util.assert(data.values != null || data.texture != null, 'Either `values` or `texture` must be defined'); + util.assert(data.texture == null || (data.textureShapeRC != null), '`textureShape` must be defined when `texture` is defined'); + this.size = util.sizeFromShape(shape); + if (data.values != null) { + util.assert(this.size === data.values.length, 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + this.shape = shape; + this.data = data; + var dim = this.shape.length; + if (dim < 2) { + this.strides = []; + } + else { + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (var i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + NDArray.zeros = function (shape) { + var values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, { values: values }); + }; + NDArray.zerosLike = function (another) { + return NDArray.zeros(another.shape); + }; + NDArray.like = function (another) { + var values = another.getValues(); + return NDArray.make(another.shape, { values: new Float32Array(values) }); + }; + NDArray.make = function (shape, data) { + switch (shape.length) { + case 0: + return new Scalar(data); + case 1: + return new Array1D(data); + case 2: + return new Array2D(shape, data); + case 3: + return new Array3D(shape, data); + case 4: + return new Array4D(shape, data); + default: + return new NDArray(shape, data); + } + }; + NDArray.prototype.reshape = function (newShape) { + if (util.arraysEqual(this.shape, newShape)) { + return this; + } + util.assert(this.size === util.sizeFromShape(newShape), 'new shape and old shape must have the same number of elements.'); + return NDArray.make(newShape, this.data); + }; + NDArray.prototype.asScalar = function () { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + }; + NDArray.prototype.as1D = function () { + return this.reshape([this.size]); + }; + NDArray.prototype.as2D = function (rows, columns) { + return this.reshape([rows, columns]); + }; + NDArray.prototype.as3D = function (rows, columns, depth) { + return this.reshape([rows, columns, depth]); + }; + NDArray.prototype.as4D = function (rows, columns, depth, depth2) { + return this.reshape([rows, columns, depth, depth2]); + }; + Object.defineProperty(NDArray.prototype, "rank", { + get: function () { + return this.shape.length; + }, + enumerable: true, + configurable: true + }); + NDArray.prototype.get = function () { + var locs = []; + for (var _i = 0; _i < arguments.length; _i++) { + locs[_i] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + }; + NDArray.prototype.add = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + this.set.apply(this, [this.get.apply(this, locs) + value].concat(locs)); + }; + NDArray.prototype.set = function (value) { + var locs = []; + for (var _i = 1; _i < arguments.length; _i++) { + locs[_i - 1] = arguments[_i]; + } + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + }; + NDArray.prototype.locToIndex = function (locs) { + var index = locs[locs.length - 1]; + for (var i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + }; + NDArray.prototype.indexToLoc = function (index) { + var locs = new Array(this.shape.length); + for (var i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + }; + NDArray.prototype.fill = function (value) { + this.getValues().fill(value); + }; + NDArray.prototype.getData = function () { + return this.data; + }; + NDArray.prototype.getValues = function () { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = exports.GPGPU.downloadMatrixFromTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1]); + this.disposeTexture(); + } + return this.data.values; + }; + NDArray.prototype.uploadToGPU = function (preferredTexShape) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape(exports.GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + exports.TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + exports.GPGPU.uploadMatrixToTexture(this.data.texture, this.data.textureShapeRC[0], this.data.textureShapeRC[1], this.data.values); + this.data.values = null; + }; + NDArray.prototype.getTexture = function (preferredShapeRC) { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture; + }; + NDArray.prototype.getTextureShapeRC = function (preferredShapeRC) { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC; + }; + NDArray.prototype.dispose = function () { + this.data.values = null; + this.shape = null; + if (this.data.texture != null) { + this.disposeTexture(); + } + }; + NDArray.prototype.disposeTexture = function () { + throwIfGPUNotInitialized(); + exports.TEXTURE_MANAGER.releaseTexture(this.data.texture, this.data.textureShapeRC); + this.data.texture = null; + this.data.textureShapeRC = null; + }; + NDArray.prototype.inGPU = function () { + return this.data.texture != null; + }; + NDArray.prototype.equals = function (t) { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + }; + NDArray.rand = function (shape, randFunction) { + var size = util.sizeFromShape(shape); + var values = new Float32Array(size); + for (var i = 0; i < size; i++) { + values[i] = randFunction(); + } + return NDArray.make(shape, { values: values }); + }; + NDArray.randNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev); }); + }; + NDArray.randTruncatedNormal = function (shape, mean, stdDev) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + return NDArray.rand(shape, function () { return util.randGauss(mean, stdDev, true); }); + }; + NDArray.randUniform = function (shape, a, b) { + return NDArray.rand(shape, function () { return util.randUniform(a, b); }); + }; + return NDArray; +}()); +exports.NDArray = NDArray; +var Scalar = (function (_super) { + __extends(Scalar, _super); + function Scalar(data) { + var _this = this; + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + _this = _super.call(this, [], data) || this; + return _this; + } + Scalar.new = function (value) { + return new Scalar({ values: new Float32Array([value]) }); + }; + Scalar.prototype.get = function () { + return this.getValues()[0]; + }; + Scalar.prototype.set = function (value) { + this.getValues()[0] = value; + }; + Scalar.prototype.add = function (value) { + this.getValues()[0] += value; + }; + return Scalar; +}(NDArray)); +Scalar.ZERO = Scalar.new(0); +Scalar.ONE = Scalar.new(1); +Scalar.TWO = Scalar.new(2); +Scalar.NEG_ONE = Scalar.new(-1); +exports.Scalar = Scalar; +var Array1D = (function (_super) { + __extends(Array1D, _super); + function Array1D(data) { + var _this = this; + var shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC)]; + _this = _super.call(this, shape, data) || this; + return _this; + } + Array1D.new = function (values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + util.assert(inferredShape.length === 1, "Error constructing Array1D. Shape of values " + inferredShape + " is " + + "not 1 dimensional."); + } + return new Array1D({ values: toTypedArray(values) }); + }; + Array1D.prototype.get = function (i) { + return this.getValues()[i]; + }; + Array1D.prototype.set = function (value, i) { + this.getValues()[i] = value; + }; + Array1D.prototype.add = function (value, i) { + this.getValues()[i] += value; + }; + Array1D.prototype.locToIndex = function (loc) { + return loc[0]; + }; + Array1D.prototype.indexToLoc = function (index) { + return [index]; + }; + Array1D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array1D; +}(NDArray)); +exports.Array1D = Array1D; +var Array2D = (function (_super) { + __extends(Array2D, _super); + function Array2D(shape, data) { + var _this = this; + util.assert(shape.length === 2, 'Shape should be of length 2'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + return _this; + } + Array2D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array2D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array2D(shape, { values: toTypedArray(values) }); + }; + Array2D.prototype.get = function (i, j) { + return this.getValues()[this.stride0 * i + j]; + }; + Array2D.prototype.set = function (value, i, j) { + this.getValues()[this.stride0 * i + j] = value; + }; + Array2D.prototype.add = function (value, i, j) { + this.getValues()[this.stride0 * i + j] += value; + }; + Array2D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + locs[1]; + }; + Array2D.prototype.indexToLoc = function (index) { + return [Math.floor(index / this.stride0), index % this.stride0]; + }; + Array2D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array2D; +}(NDArray)); +exports.Array2D = Array2D; +var Array3D = (function (_super) { + __extends(Array3D, _super); + function Array3D(shape, data) { + var _this = this; + util.assert(shape.length === 3, 'Shape should be of length 3'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + return _this; + } + Array3D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array3D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array3D(shape, { values: toTypedArray(values) }); + }; + Array3D.prototype.get = function (i, j, k) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + }; + Array3D.prototype.set = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + }; + Array3D.prototype.add = function (value, i, j, k) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + }; + Array3D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + }; + Array3D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + }; + Array3D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array3D; +}(NDArray)); +exports.Array3D = Array3D; +var Array4D = (function (_super) { + __extends(Array4D, _super); + function Array4D(shape, data) { + var _this = this; + util.assert(shape.length === 4, 'Shape should be of length 4'); + _this = _super.call(this, shape, data) || this; + _this.stride0 = _this.strides[0]; + _this.stride1 = _this.strides[1]; + _this.stride2 = _this.strides[2]; + return _this; + } + Array4D.new = function (shape, values) { + if (!(values instanceof Float32Array)) { + var inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch(shape, inferredShape, "Error when constructing Array4D. Shape of values " + + (inferredShape + " does not match the provided shape ") + + (shape + ". ")); + } + } + return new Array4D(shape, { values: toTypedArray(values) }); + }; + Array4D.prototype.get = function (i, j, k, l) { + return this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + }; + Array4D.prototype.set = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + }; + Array4D.prototype.add = function (value, i, j, k, l) { + this.getValues()[this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + }; + Array4D.prototype.locToIndex = function (locs) { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + }; + Array4D.prototype.indexToLoc = function (index) { + var i = Math.floor(index / this.stride0); + index -= i * this.stride0; + var j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + }; + Array4D.zeros = function (shape) { + return NDArray.zeros(shape); + }; + return Array4D; +}(NDArray)); +exports.Array4D = Array4D; +function toTypedArray(a) { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} + +},{"../util":87,"./webgl/webgl_util":59}],24:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n uniform sampler2D matrixAScalar;\n uniform sampler2D matrixBScalar;\n varying vec2 resultUV;\n\n const vec2 halfTexel = vec2(0.5, 0.5);\n\n void main() {\n float a = texture2D(matrixA, resultUV).r;\n float b = texture2D(matrixB, resultUV).r;\n float aScalar = texture2D(matrixAScalar, halfTexel).r;\n float bScalar = texture2D(matrixBScalar, halfTexel).r;\n vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar);\n gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function addScaledMatrices(gpgpu, addScaledMatricesProgram, a, b, rows, columns, aScalar, bScalar, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} +exports.addScaledMatrices = addScaledMatrices; +function uploadAddScaledMatricesDownload(a, b, rows, columns, aScalar, bScalar) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource()); + var aTex = gpgpu.createMatrixTexture(rows, columns); + var bTex = gpgpu.createMatrixTexture(rows, columns); + var aScalarTex = gpgpu.createMatrixTexture(1, 1); + var bScalarTex = gpgpu.createMatrixTexture(1, 1); + var resultTex = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + addScaledMatrices(gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, resultTex); + var result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadAddScaledMatricesDownload = uploadAddScaledMatricesDownload; + +},{"./gpgpu_context":36}],25:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var binaryop_gpu = require("./binaryop_gpu"); +var OperandType; +(function (OperandType) { + OperandType[OperandType["MATRIX"] = 0] = "MATRIX"; + OperandType[OperandType["SCALAR"] = 1] = "SCALAR"; +})(OperandType = exports.OperandType || (exports.OperandType = {})); +function getFragmentShaderSource(aType, aOrientation, op, bType, bOrientation) { + var aUV = operandToShaderSnippet(aType, aOrientation); + var bUV = operandToShaderSnippet(bType, bOrientation); + var resultOp = "gl_FragColor = vec4(a " + op + " b, 0, 0, 0);"; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function operandToShaderSnippet(operand, orientation) { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === math_1.MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} +function addSubMulDiv(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + return binaryop_gpu.binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol); +} +exports.addSubMulDiv = addSubMulDiv; +function uploadScalarPlusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarPlusMatrixDownload = uploadScalarPlusMatrixDownload; +function uploadMatrixMinusScalarDownload(a, aShape, b, aOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, math_1.MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload(a, aShape, new Float32Array([b]), [1, 1], src); +} +exports.uploadMatrixMinusScalarDownload = uploadMatrixMinusScalarDownload; +function uploadScalarMinusMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '-', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarMinusMatrixDownload = uploadScalarMinusMatrixDownload; +function uploadScalarTimesMatrixDownload(a, b, bShape, bOrientation) { + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.SCALAR, math_1.MatrixOrientation.REGULAR, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(new Float32Array([a]), [1, 1], b, bShape, src); +} +exports.uploadScalarTimesMatrixDownload = uploadScalarTimesMatrixDownload; +function uploadMatrixTimesMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixTimesMatrixDownload = uploadMatrixTimesMatrixDownload; +function uploadMatrixPlusMatrixDownload(a, b, shape, aOrientation, bOrientation) { + if (aOrientation === void 0) { aOrientation = math_1.MatrixOrientation.REGULAR; } + if (bOrientation === void 0) { bOrientation = math_1.MatrixOrientation.REGULAR; } + var src = getFragmentShaderSource(OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} +exports.uploadMatrixPlusMatrixDownload = uploadMatrixPlusMatrixDownload; + +},{"../math":20,"./binaryop_gpu":30}],26:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var argminmax_gpu = require("./argminmax_gpu"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;"; +} +function getFragmentShaderMainSource() { + return "\n void main() {\n float argMaxA = getArgMinMax(matrixA);\n float argMaxB = getArgMinMax(matrixB);\n float value;\n if (isNaN(argMaxA)) {\n value = argMaxA;\n } else if (isNaN(argMaxB)) {\n value = argMaxB;\n } else {\n value = float(argMaxA == argMaxB);\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getArgMaxEqualsFragmentShaderSource(rows, columns) { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +exports.getArgMaxEqualsFragmentShaderSource = getArgMaxEqualsFragmentShaderSource; +function argMaxEquals(gpgpu, maxEqualsProgram, a, b, numRows, numCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.argMaxEquals = argMaxEquals; + +},{"./argminmax_gpu":27}],27:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderMainSource() { + return "\n void main() {\n gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0);\n }"; +} +function getArgMinMaxFragmentShaderSource(rows, columns, compOp) { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} +function getArgMinFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} +exports.getArgMinFragmentShaderSource = getArgMinFragmentShaderSource; +function getArgMaxFragmentShaderSource(rows, columns) { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} +exports.getArgMaxFragmentShaderSource = getArgMaxFragmentShaderSource; +function getFragmentShaderGetArgMinMaxSource(compOp, rows, columns) { + return "\n const vec2 dimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n float getArgMinMax(in sampler2D matrix) {\n vec2 bestCR = vec2(0, 0);\n float bestValue = texture2D(matrix, bestCR).r;\n\n for (float c = 0.0; c < dimCR.x; c += 1.0) {\n for (float r = 0.0; r < dimCR.y; r += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / dimCR;\n float value = texture2D(matrix, uv).r;\n if (isNaN(value)) {\n return value;\n }\n if (value " + compOp + " bestValue) {\n bestValue = value;\n bestCR = cr;\n }\n }\n }\n return bestCR.x + (bestCR.y * dimCR.x);\n }\n "; +} +exports.getFragmentShaderGetArgMinMaxSource = getFragmentShaderGetArgMinMaxSource; +function argMinMax(gpgpu, minMaxProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.argMinMax = argMinMax; + +},{"./webgl_util":59}],28:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderAvgPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'avg', false); +} +exports.getFragmentShaderAvgPoolSource = getFragmentShaderAvgPoolSource; +function avgPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.avgPool = avgPool; + +},{"./pool_gpu":46}],29:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(xTexShapeRC, meanTexShapeRC, varianceTexShapeRC, offsetTexShapeRC, scaleTexShapeRC, varianceEpsilon) { + if (varianceEpsilon === void 0) { varianceEpsilon = 0.001; } + var offsetSamplerSnippet = ''; + var offsetShapeInitializationSnippet = ''; + var offsetCoordsSnippet = ''; + var offsetUVSnippet = ''; + var offsetValueSnippet = ''; + var offsetOperationSnippet = '0.0'; + var scaleSamplerSnippet = ''; + var scaleShapeInitializationSnippet = ''; + var scaleCoordsSnippet = ''; + var scaleUVSnippet = ''; + var scaleValueSnippet = ''; + var scaleOperationSnippet = ''; + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = "const vec2 offsetShapeCR = vec2(\n " + offsetTexShapeRC[1] + ", " + offsetTexShapeRC[0] + ");"; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = "const vec2 scaleShapeCR = vec2(\n " + scaleTexShapeRC[1] + ", " + scaleTexShapeRC[0] + ");"; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D mean;\n uniform sampler2D variance;\n " + offsetSamplerSnippet + "\n " + scaleSamplerSnippet + "\n\n varying vec2 resultUV;\n\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 meanShapeCR = vec2(" + meanTexShapeRC[1] + ", " + meanTexShapeRC[0] + ");\n const vec2 varianceShapeCR = vec2(\n " + varianceTexShapeRC[1] + ", " + varianceTexShapeRC[0] + ");\n\n " + offsetShapeInitializationSnippet + "\n " + scaleShapeInitializationSnippet + "\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const float varianceEpsilon = " + varianceEpsilon + ";\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n vec2 meanCoordsCR = mod(yTexCR, meanShapeCR);\n vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR);\n " + offsetCoordsSnippet + "\n " + scaleCoordsSnippet + "\n\n vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR;\n vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR;\n " + offsetUVSnippet + "\n " + scaleUVSnippet + "\n\n float xValue = texture2D(x, resultUV).r;\n float meanValue = texture2D(mean, meanUV).r;\n float varianceValue = texture2D(variance, varianceUV).r;\n " + offsetValueSnippet + "\n " + scaleValueSnippet + "\n\n float inv = 1.0 / sqrt(varianceValue + varianceEpsilon);\n " + scaleOperationSnippet + "\n float xTimesInv = xValue * inv;\n float meanTimesInvWithOffset = " + offsetOperationSnippet + "\n - meanValue * inv;\n\n gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function batchNormalization(gpgpu, program, x, xShapeRowCol, mean, meanShapeRowCol, variance, varianceShapeRowCol, offset, offsetShapeRowCol, scale, scaleShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + var nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} +exports.batchNormalization = batchNormalization; + +},{}],30:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(aResultUV, bResultUV, op) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform sampler2D matrixB;\n varying vec2 resultUV;\n\n void main() {\n float a = texture2D(matrixA, " + aResultUV + ").r;\n float b = texture2D(matrixB, " + bResultUV + ").r;\n " + op + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function binaryOp(gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.binaryOp = binaryOp; +function uploadBinaryOpDownload(a, aShape, b, bShape, fragmentShaderSource) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(fragmentShaderSource); + var aTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + var bTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + var resultShape = [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + var resultTexture = gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + binaryOp(gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, resultShape); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, resultShape[0], resultShape[1]); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadBinaryOpDownload = uploadBinaryOpDownload; + +},{"./gpgpu_context":36}],31:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis) { + var x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + var x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + var yAxes = ['yR', 'yC', 'yD']; + var concatAxis = yAxes[axis]; + return "\n precision highp float;\n uniform sampler2D x1;\n uniform sampler2D x2;\n\n const vec2 x1ShapeCR = vec2(" + x1TexShapeRC[1] + ", " + x1TexShapeRC[0] + ");\n const vec2 x2ShapeCR = vec2(" + x2TexShapeRC[1] + ".0, " + x2TexShapeRC[0] + ".0);\n\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + resultShapeRCD[2] + ".0);\n float yD = mod(yTexCR.x, " + resultShapeRCD[2] + ".0);\n\n float value = 0.0;\n\n if (" + concatAxis + " < " + x1ShapeRCD[axis] + ".0) {\n // Map yR, yC, yD back to x1 coordinates.\n vec2 x1CR = vec2(yC * " + x1ShapeRCD[2] + ".0 + yD, yR);\n vec2 x1UV = (x1CR + halfCR) / x1ShapeCR;\n value = texture2D(x1, x1UV).r;\n } else {\n " + concatAxis + " = " + concatAxis + " - " + x1ShapeRCD[axis] + ".0;\n\n // Map yR, yC, yD back to x2 coordinates.\n vec2 x2CR = vec2(yC * " + x2ShapeRCD[2] + ".0 + yD, yR);\n vec2 x2UV = (x2CR + halfCR) / x2ShapeCR;\n value = texture2D(x2, x2UV).r;\n }\n\n gl_FragColor = vec4(value, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function concat3D(gpgpu, program, x1, x2, result, resultShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} +exports.concat3D = concat3D; + +},{"../conv_util":17}],32:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var conv_gpu = require("./conv_gpu"); +function getFragmentShaderDerWeightsSource(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad) { + var getMatrixValueOrZeroPad = conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + var inputDepth = xShapeRowColDepth[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + var yShape = conv_util.computeOutputShape3D(xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + var yNumRows = yShape[0]; + var yNumCols = yShape[1]; + var yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + var fSizeTimesInputDepth = fSize * inputDepth; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D dy;\n "; + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 dyShapeCR = vec2(" + yTexShapeRC[1] + ", " + yTexShapeRC[0] + ");\n\n void main() {\n vec2 wTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2).\n float wR = floor(wTexCR.y / " + fSizeTimesInputDepth + ".0);\n float wTexRLeftover = wTexCR.y - wR * " + fSizeTimesInputDepth + ".0;\n float wC = floor(wTexRLeftover / " + inputDepth + ".0);\n float d1 = mod(wTexRLeftover, " + inputDepth + ".0);\n float d2 = wTexCR.x;\n\n // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float xR = wR + yR * " + stride + ".0 - " + zeroPad + ".0;\n float xTexR = xR;\n float yTexR = yR;\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n float xC = wC + yC * " + stride + ".0 - " + zeroPad + ".0;\n\n // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC).\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n vec2 xyTexC = vec2(xC, yC) * vec2(" + inputDepth + ".0, " + outputDepth + ".0) +\n vec2(d1, d2);\n float xTexC = xyTexC.x;\n float yTexC = xyTexC.y;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read x(xR, xC, d1) (potentially zero-padded).\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n dotProd += (xValue * dyValue);\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderDerWeightsSource = getFragmentShaderDerWeightsSource; +function getFragmentShaderConvTransposeSource(xShapeRCD, fSize, origInputDepth, origStride, origPad, hasBias) { + var pad = fSize - 1 - origPad; + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], origOutputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + var getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + var biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + var biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + var prologue = "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n " + biasPrologue + "\n "; + return prologue + '\n' + getBiasValue + '\n' + + ("\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + origInputDepth + ".0);\n float d2 = mod(yTexCR.x, " + origInputDepth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) - vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float xR = (xRCorner + wR) / " + origStride + ".0;\n // TODO(smilkov): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (xR < 0.0 || xR >= " + xRows + ".0 || fract(xR) > 0.0) {\n continue;\n }\n\n float wRPerm = " + fSize + ".0 - 1.0 - wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float xC = (xCCorner + wC) / " + origStride + ".0;\n if (xC < 0.0 || xC >= " + xCols + ".0 || fract(xC) > 0.0) {\n continue;\n }\n\n float wCPerm = " + fSize + ".0 - 1.0 - wC;\n float wTexR = wRPerm * " + fSize + ".0 * " + origInputDepth + ".0 +\n wCPerm * " + origInputDepth + ".0 + d2;\n\n for (float d1 = 0.0; d1 < " + origOutputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + origOutputDepth + ".0 + d1;\n float wTexC = d1;\n\n // Read x(xR, xC, d1).\n vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR;\n float xValue = texture2D(x, xUV).r;\n\n // Read w(wRPerm, wCPerm, d2, d1).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n " + biasOperation + "\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"); +} +exports.getFragmentShaderConvTransposeSource = getFragmentShaderConvTransposeSource; +function getFragmentShaderDerBiasSource(dyShapeRCD) { + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + var yNumRows = dyShapeRCD[0], yNumCols = dyShapeRCD[1], outputDepth = dyShapeRCD[2]; + return "\n precision highp float;\n uniform sampler2D dy;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 biasTexCR = floor(gl_FragCoord.xy);\n\n // The bias texture RC shape is [1, d2].\n float d2 = biasTexCR.x;\n\n float derBias = 0.0;\n for (float yR = 0.0; yR < " + yNumRows + ".0; yR += 1.0) {\n float yTexR = yR;\n\n for (float yC = 0.0; yC < " + yNumCols + ".0; yC += 1.0) {\n // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC).\n float yTexC = yC * " + outputDepth + ".0 + d2;\n\n // Read dy(yR, yC, d2).\n vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n derBias += dyValue;\n }\n }\n gl_FragColor = vec4(derBias, 0, 0, 0);\n }"; +} +exports.getFragmentShaderDerBiasSource = getFragmentShaderDerBiasSource; +function derBias(gpgpu, program, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} +exports.derBias = derBias; +function derWeights(gpgpu, program, xTex, dyTex, result, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} +exports.derWeights = derWeights; +function convTranspose(gpgpu, program, xTex, weightsTex, biasesTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convTranspose = convTranspose; + +},{"../conv_util":17,"./conv_gpu":33}],33:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderPrologueSource() { + return "\n precision highp float;\n uniform sampler2D x;\n uniform sampler2D weights;\n uniform sampler2D biases;\n varying vec2 resultUV;"; +} +exports.getFragmentShaderPrologueSource = getFragmentShaderPrologueSource; +function getFragmentShaderGetMatrixValueOrZeroPadSource() { + return "\n float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR,\n vec2 requestedCR) {\n vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR;\n float value = texture2D(matrix, uv).r;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n return mix(value, 0.0, float(outside));\n }"; +} +exports.getFragmentShaderGetMatrixValueOrZeroPadSource = getFragmentShaderGetMatrixValueOrZeroPadSource; +function getFragmentShaderConvolveSource(xShapeRCD, fSize, outputDepth, stride, pad, hasBias) { + var xRows = xShapeRCD[0], xCols = xShapeRCD[1], inputDepth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var wTexShapeRC = conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + return "\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n const vec2 wShapeCR = vec2(" + wTexShapeRC[1] + ", " + wTexShapeRC[0] + ");\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + outputDepth + ".0);\n float d2 = mod(yTexCR.x, " + outputDepth + ".0);\n float wTexC = d2;\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n\n for (float d1 = 0.0; d1 < " + inputDepth + ".0; d1 += 1.0) {\n float xTexC = xC * " + inputDepth + ".0 + d1;\n float wTexR = wR * " + fSize * inputDepth + ".0 +\n wC * " + inputDepth + ".0 + d1;\n\n float xValue =\n getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR));\n\n // Read w(wR, wC, d1, d2).\n vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR;\n float wValue = texture2D(weights, wUV).r;\n\n dotProd += xValue * wValue;\n }\n }\n }\n if (" + hasBias + ") {\n dotProd += getBiasValue(biases, d2);\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderConvolveSource = getFragmentShaderConvolveSource; +function getFragmentShaderGetBiasValueSource(outputDepth) { + return "\n float getBiasValue(in sampler2D bias, float biasC) {\n const vec2 biasShapeCR = vec2(" + outputDepth + ", 1);\n vec2 biasCR = vec2(mod(biasC, " + outputDepth + ".0), 0);\n vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR;\n return texture2D(bias, biasUV).r;\n }"; +} +exports.getFragmentShaderGetBiasValueSource = getFragmentShaderGetBiasValueSource; +function getFragmentShaderSource(aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, hasBias) { + var aShapeRC = conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + var weightShapeRC = conv_util.computeWeightsTexShape(aShapeRowColDepth[2], resultDepth, fieldSize); + var prologue = getFragmentShaderPrologueSource(); + var getMatrixValueOrZeroPad = getFragmentShaderGetMatrixValueOrZeroPadSource(); + var convolve = getFragmentShaderConvolveSource(aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + var getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function convolve(gpgpu, program, a, weights, biases, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} +exports.convolve = convolve; + +},{"../conv_util":17}],34:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getFragmentShaderSource(sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol) { + return "\n precision highp float;\n uniform sampler2D source;\n uniform vec2 sourceStartCR;\n uniform vec2 destStartCR;\n\n const vec2 sourceShapeCR =\n vec2(" + sourceShapeRowCol[1] + ", " + sourceShapeRowCol[0] + ");\n const vec2 sourceSizeCR =\n vec2(" + sourceSizeRowCol[1] + ", " + sourceSizeRowCol[0] + ");\n const vec2 destSizeCR =\n vec2(" + destSizeRowCol[1] + ", " + destSizeRowCol[0] + ");\n\n void main() {\n vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR;\n float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x;\n vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x),\n floor(destOffsetFlat / sourceSizeCR.x));\n vec2 sourceCR = sourceStartCR + sourceOffsetCR;\n vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR;\n gl_FragColor = texture2D(source, sourceUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function copy(gpgpu, program, source, sourceShapeRowCol, sourceStartRowCol, sourceSizeRowCol, dest, destShapeRowCol, destStartRowCol, destSizeRowCol) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion(destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + var sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f(sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + var destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} +exports.copy = copy; + +},{}],35:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getExpUnaryOp() { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function exp(gpgpu, expProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} +exports.exp = exp; +function uploadExpDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} +exports.uploadExpDownload = uploadExpDownload; + +},{"./unaryop_gpu":58}],36:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_util = require("./gpgpu_util"); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +var GPGPUContext = (function () { + function GPGPUContext(gl) { + this.outputTexture = null; + this.program = null; + this.disposed = false; + this.autoDebugValidate = false; + if (gl != null) { + this.gl = gl; + } + else { + this.gl = gpgpu_util.createWebGLContext(); + } + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } + else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context'); + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + GPGPUContext.prototype.dispose = function () { + var _this = this; + this.throwIfDisposed(); + if (this.program != null) { + console.warn('Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn('Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + var gl = this.gl; + webgl_util.callAndCheck(gl, function () { return gl.finish(); }); + webgl_util.callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteFramebuffer(_this.framebuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.vertexBuffer); }); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteBuffer(_this.indexBuffer); }); + this.loseContextExtension.loseContext(); + this.disposed = true; + }; + GPGPUContext.prototype.enableAutomaticDebugValidation = function (enabled) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + }; + GPGPUContext.prototype.createMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.uploadPixelDataToTexture = function (texture, pixels) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + }; + GPGPUContext.prototype.createPackedMatrixTexture = function (rows, columns) { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + }; + GPGPUContext.prototype.deleteMatrixTexture = function (texture) { + var _this = this; + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteTexture(texture); }); + }; + GPGPUContext.prototype.uploadMatrixToTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + var numChannels = 1; + return gpgpu_util.uploadMatrixToTexture(this.gl, texture, rows, columns, matrix, numChannels); + }; + GPGPUContext.prototype.uploadMatrixToPackedTexture = function (texture, rows, columns, matrix) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture(this.gl, texture, rows, columns, matrix); + }; + GPGPUContext.prototype.downloadMatrixFromTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { + return gpgpu_util.downloadMatrixFromOutputTexture(_this.gl, rows, columns); + }); + }; + GPGPUContext.prototype.downloadMatrixFromPackedTexture = function (texture, rows, columns) { + var _this = this; + return this.downloadMatrixDriver(texture, function () { return gpgpu_util.downloadMatrixFromPackedOutputTexture(_this.gl, rows, columns); }); + }; + GPGPUContext.prototype.createProgram = function (fragmentShaderSource) { + this.throwIfDisposed(); + var gl = this.gl; + var fragmentShader = webgl_util.createFragmentShader(gl, fragmentShaderSource); + var vertexShader = gpgpu_util.createVertexShader(gl); + var program = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.attachShader(program, fragmentShader); }); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(vertexShader); }); + webgl_util.callAndCheck(gl, function () { return gl.detachShader(program, fragmentShader); }); + webgl_util.callAndCheck(gl, function () { return gl.deleteShader(fragmentShader); }); + return program; + }; + GPGPUContext.prototype.deleteProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, function () { return _this.gl.deleteProgram(program); }); + } + }; + GPGPUContext.prototype.setProgram = function (program) { + var _this = this; + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, function () { return _this.gl.useProgram(program); }); + }; + GPGPUContext.prototype.getUniformLocation = function (uniformName) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow(this.gl, this.program, uniformName); + }; + GPGPUContext.prototype.setInputMatrixTexture = function (inputMatrixTexture, uniformName, textureUnit) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler(this.gl, this.program, inputMatrixTexture, uniformName, textureUnit); + }; + GPGPUContext.prototype.setOutputMatrixTexture = function (outputMatrixTexture, rows, columns) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + }; + GPGPUContext.prototype.setOutputPackedMatrixTexture = function (outputPackedMatrixTexture, rows, columns) { + this.throwIfDisposed(); + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + this.setOutputMatrixWriteRegionDriver(startColumn, startRow, numColumns, numRows); + }; + GPGPUContext.prototype.setOutputPackedMatrixWriteRegion = function (startRow, numRows, startColumn, numColumns) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + }; + GPGPUContext.prototype.debugValidate = function () { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + }; + GPGPUContext.prototype.executeProgram = function () { + this.throwIfDisposed(); + this.throwIfNoProgram(); + var gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams(gl, this.program, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck(gl, function () { return gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0); }); + }; + GPGPUContext.prototype.blockUntilAllProgramsCompleted = function () { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.finish(); }); + }; + GPGPUContext.prototype.downloadMatrixDriver = function (texture, downloadAndDecode) { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer(this.gl, texture, this.framebuffer); + var result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer(this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } + else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + }; + GPGPUContext.prototype.setOutputMatrixTextureDriver = function (outputMatrixTextureMaybePacked, width, height) { + this.throwIfDisposed(); + var gl = this.gl; + webgl_util.bindColorTextureToFramebuffer(gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, function () { return gl.viewport(0, 0, width, height); }); + webgl_util.callAndCheck(gl, function () { return gl.scissor(0, 0, width, height); }); + }; + GPGPUContext.prototype.setOutputMatrixWriteRegionDriver = function (x, y, width, height) { + var _this = this; + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, function () { return _this.gl.scissor(x, y, width, height); }); + }; + GPGPUContext.prototype.throwIfDisposed = function () { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + }; + GPGPUContext.prototype.throwIfNoProgram = function () { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + }; + return GPGPUContext; +}()); +exports.GPGPUContext = GPGPUContext; + +},{"./gpgpu_util":37,"./tex_util":55,"./webgl_util":59}],37:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var tex_util = require("./tex_util"); +var webgl_util = require("./webgl_util"); +function getWebGLContextAttributes() { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} +exports.getWebGLContextAttributes = getWebGLContextAttributes; +function createWebGLContext(canvas) { + var attributes = getWebGLContextAttributes(); + var gl; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } + else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DEPTH_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.STENCIL_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.BLEND); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.DITHER); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.POLYGON_OFFSET_FILL); }); + webgl_util.callAndCheck(gl, function () { return gl.disable(gl.SAMPLE_COVERAGE); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.SCISSOR_TEST); }); + webgl_util.callAndCheck(gl, function () { return gl.enable(gl.CULL_FACE); }); + webgl_util.callAndCheck(gl, function () { return gl.cullFace(gl.BACK); }); + return gl; +} +exports.createWebGLContext = createWebGLContext; +function createVertexShader(gl) { + var vertexShaderSource = "\n precision highp float;\n attribute vec3 clipSpacePos;\n attribute vec2 uv;\n varying vec2 resultUV;\n\n void main() {\n gl_Position = vec4(clipSpacePos, 1);\n resultUV = uv;\n }"; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} +exports.createVertexShader = createVertexShader; +function createVertexBuffer(gl) { + var vertexArray = new Float32Array([-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} +exports.createVertexBuffer = createVertexBuffer; +function createIndexBuffer(gl) { + var triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} +exports.createIndexBuffer = createIndexBuffer; +function getTextureInternalFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + return gl.RGBA32F; + } + return gl.R32F; + } + return gl.RGBA; +} +function getTextureFormat(gl, numChannels) { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + return gl.RED; + } + return gl.RGBA; +} +function createAndConfigureTexture(gl, width, height, numChannels) { + webgl_util.validateTextureSize(gl, width, height); + var texture = webgl_util.createTexture(gl); + var tex2d = gl.TEXTURE_2D; + var internalFormat = getTextureInternalFormat(gl, numChannels); + var format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(tex2d, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); + return texture; +} +function createMatrixTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createMatrixTexture = createMatrixTexture; +function createColorMatrixTexture(gl, rows, columns) { + var _a = tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createColorMatrixTexture = createColorMatrixTexture; +function createPackedMatrixTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), width = _a[0], height = _a[1]; + var numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} +exports.createPackedMatrixTexture = createPackedMatrixTexture; +function bindVertexProgramAttributeStreams(gl, program, vertexBuffer) { + var posOffset = 0; + var uvOffset = 3 * 4; + var stride = (3 * 4) + (2 * 4); + webgl_util.callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); }); + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute(gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } + catch (e) { + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} +exports.bindVertexProgramAttributeStreams = bindVertexProgramAttributeStreams; +function uploadPixelDataToTexture(gl, texture, pixels) { + var numChannels = 4; + var internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.uploadPixelDataToTexture = uploadPixelDataToTexture; +function uploadDataToTexture(gl, texture, width, height, data, numChannels) { + var textureFormat = getTextureFormat(gl, numChannels); + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); + webgl_util.callAndCheck(gl, function () { return gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, data); }); + webgl_util.callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +function uploadMatrixToTexture(gl, texture, rows, columns, matrix, numChannels) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture); + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} +exports.uploadMatrixToTexture = uploadMatrixToTexture; +function uploadMatrixToPackedTexture(gl, texture, rows, columns, matrix) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + var numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} +exports.uploadMatrixToPackedTexture = uploadMatrixToPackedTexture; +function downloadMatrixFromOutputTexture(gl, rows, columns) { + var _a = tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var channelsPerTexture = 4; + var unpackedArray = new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize(rows * columns, channelsPerTexture)); + var textureFormat = getTextureFormat(gl, channelsPerTexture); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray); }); + var matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture); + return matrix; +} +exports.downloadMatrixFromOutputTexture = downloadMatrixFromOutputTexture; +function downloadMatrixFromPackedOutputTexture(gl, rows, columns) { + var _a = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + var packedRGBA = new Float32Array(tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck(gl, function () { return gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA); }); + var matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} +exports.downloadMatrixFromPackedOutputTexture = downloadMatrixFromPackedOutputTexture; + +},{"./tex_util":55,"./webgl_util":59}],38:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getLogUnaryOp() { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function log(gpgpu, logProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} +exports.log = log; +function uploadLogDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} +exports.uploadLogDownload = uploadLogDownload; + +},{"./unaryop_gpu":58}],39:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float aMax = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n aMax = max(aMax, aCur);\n }\n }\n\n float expSum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n float aCur = texture2D(matrixA, uv).r;\n expSum += exp(aCur - aMax);\n }\n }\n\n gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function logSumExp(gpgpu, logSumExpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.logSumExp = logSumExp; +function uploadLogSumExpDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} +exports.uploadLogSumExpDownload = uploadLogSumExpDownload; + +},{"./gpgpu_context":36}],40:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderMaxPoolBackprop(dyShapeRCD, fSize, origStride, origPad) { + var origInputDepth = dyShapeRCD[2]; + var pad = fSize - 1 - origPad; + var dyRows = dyShapeRCD[0], dyCols = dyShapeRCD[1], depth = dyShapeRCD[2]; + var dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + return "\n precision highp float;\n uniform sampler2D dy;\n uniform sampler2D maxPos;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 dyShapeCR = vec2(" + dyTexShapeRC[1] + ", " + dyTexShapeRC[0] + ");\n\n void main() {\n vec2 dxTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d).\n float dxR = dxTexCR.y;\n float dxC = floor(dxTexCR.x / " + origInputDepth + ".0);\n float d = mod(dxTexCR.x, " + origInputDepth + ".0);\n\n vec2 dyRCCorner = vec2(dxR, dxC) - vec2(" + pad + ".0, " + pad + ".0);\n float dyRCorner = dyRCCorner.x;\n float dyCCorner = dyRCCorner.y;\n\n // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d).\n // ? = to be determined. : = across all values in that axis.\n float dotProd = 0.0;\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n\n float dyR = (dyRCorner + wR) / " + origStride + ".0;\n // TODO(nsthorat): Splice this with another version where you call\n // getMatrixValueOrZeroPad(). Here and below.\n if (dyR < 0.0 || dyR >= " + dyRows + ".0 || fract(dyR) > 0.0) {\n continue;\n }\n\n float dyTexR = dyR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n\n float dyC = (dyCCorner + wC) / " + origStride + ".0;\n if (dyC < 0.0 || dyC >= " + dyCols + ".0 || fract(dyC) > 0.0) {\n continue;\n }\n\n float dyTexC = dyC * " + depth + ".0 + d;\n\n // Read dy(dyR, dyC, d).\n vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR;\n float dyValue = texture2D(dy, dyUV).r;\n\n // Read maxPos(dyR, dyC, d).\n float maxPosValue =\n " + (fSize * fSize - 1) + ".0 - texture2D(maxPos, dyUV).r;\n\n // Get the current value, check it against the value from the\n // position matrix.\n float curPosValue = wR * " + fSize + ".0 + wC;\n float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);\n\n dotProd += dyValue * mask;\n }\n }\n gl_FragColor = vec4(dotProd, 0, 0, 0);\n }"; +} +exports.getFragmentShaderMaxPoolBackprop = getFragmentShaderMaxPoolBackprop; +function maxPoolBackprop(gpgpu, program, dyTex, maxPositionsTex, resultTex, resultTexShapeRC) { + gpgpu.setOutputMatrixTexture(resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} +exports.maxPoolBackprop = maxPoolBackprop; + +},{"../conv_util":17}],41:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMaxPoolPositionsSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, true); +} +exports.getFragmentShaderMaxPoolPositionsSource = getFragmentShaderMaxPoolPositionsSource; +function getFragmentShaderMaxPoolSource(xShapeRCD, fSize, stride, pad) { + return getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, false); +} +exports.getFragmentShaderMaxPoolSource = getFragmentShaderMaxPoolSource; +function getFragmentShaderMaxPoolCommonSource(xShapeRCD, fSize, stride, pad, computeMaxPositions) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} +function maxPoolCommon(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.maxPoolCommon = maxPoolCommon; + +},{"./pool_gpu":46}],42:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var pool_gpu = require("./pool_gpu"); +function getFragmentShaderMinPoolSource(xShapeRCD, fSize, stride, pad) { + return pool_gpu.getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, 'min', false); +} +exports.getFragmentShaderMinPoolSource = getFragmentShaderMinPoolSource; +function minPool(gpgpu, program, x, result, resultShapeRowCol) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} +exports.minPool = minPool; + +},{"./pool_gpu":46}],43:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderSource(rows, columns, compOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 outputColumnRow;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n float value = texture2D(matrixA, halfCR / aDimCR).r;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 cr = vec2(c, r);\n vec2 uv = (cr + halfCR) / aDimCR;\n float candidate = texture2D(matrixA, uv).r;\n if (isNaN(candidate)) {\n gl_FragColor = vec4(candidate, 0, 0, 0);\n return;\n }\n value = " + compOp + "(value, candidate);\n }\n }\n gl_FragColor = vec4(value, 0, 0, 0);\n }"; +} +function getMinFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'min'); +} +exports.getMinFragmentShaderSource = getMinFragmentShaderSource; +function getMaxFragmentShaderSource(rows, columns) { + return getFragmentShaderSource(rows, columns, 'max'); +} +exports.getMaxFragmentShaderSource = getMaxFragmentShaderSource; +function minMax(gpgpu, minMaxProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.minMax = minMax; + +},{"./webgl_util":59}],44:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var math_1 = require("../math"); +var shader_compiler = require("./shader_compiler"); +function getFragmentShader(a, b, out, aOrientation, bOrientation) { + var sharedDim = (aOrientation === math_1.MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + var aSnippet = (aOrientation === math_1.MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + var bSnippet = (bOrientation === math_1.MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + var inputs = [{ name: 'matrixA', array: a }, { name: 'matrixB', array: b }]; + var userCode = "\n const float sharedDim = " + sharedDim + ".0;\n\n float dotARowBCol(float aRow, float bCol) {\n float result = 0.0;\n for (float i = 0.0; i < sharedDim; i += 1.0) {\n float a = getMatrixA(" + aSnippet + ");\n float b = getMatrixB(" + bSnippet + ");\n result += (a * b);\n }\n return result;\n }\n\n void main() {\n vec2 resRC = getOutputCoords();\n setOutput(dotARowBCol(resRC.x, resRC.y));\n }\n "; + return shader_compiler.makeShader(inputs, out, userCode); +} +exports.getFragmentShader = getFragmentShader; +function multiplyMatrix(gpgpu, multiplyProgram, a, b, result, outTexShape) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} +exports.multiplyMatrix = multiplyMatrix; + +},{"../math":20,"./shader_compiler":52}],45:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getNegUnaryOp() { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function neg(gpgpu, program, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} +exports.neg = neg; +function uploadNegDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} +exports.uploadNegDownload = uploadNegDownload; + +},{"./unaryop_gpu":58}],46:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +var webgl_util_1 = require("./webgl_util"); +function getFragmentShaderPoolCommonSource(xShapeRCD, fSize, stride, pad, poolType, computePositions) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + var depth = xShapeRCD[2]; + var xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + var returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } + else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + return "\n precision highp float;\n uniform sampler2D x;\n varying vec2 resultUV;\n\n const vec2 halfCR = vec2(0.5, 0.5);\n const vec2 xShapeCR = vec2(" + xTexShapeRC[1] + ", " + xTexShapeRC[0] + ");\n\n " + webgl_util_1.IS_NAN_SHADER_FUNC + "\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2).\n float yR = yTexCR.y;\n float yC = floor(yTexCR.x / " + depth + ".0);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n vec2 xRCCorner = vec2(yR, yC) * vec2(" + stride + ", " + stride + ") -\n vec2(" + pad + ".0, " + pad + ".0);\n float xRCorner = xRCCorner.x;\n float xCCorner = xRCCorner.y;\n\n // max/min x(?, ?, d) to get y(yR, yC, d).\n // ? = to be determined\n float minMaxValue = 0.0;\n float minMaxValueFound = 0.0;\n float minMaxPosition = 0.0;\n float avgValue = 0.0;\n\n for (float wR = 0.0; wR < " + fSize + ".0; wR += 1.0) {\n float xR = xRCorner + wR;\n float xTexR = xR;\n\n for (float wC = 0.0; wC < " + fSize + ".0; wC += 1.0) {\n float xC = xCCorner + wC;\n float xTexC = xC * " + depth + ".0 + d;\n\n vec2 texCR = vec2(xTexC, xTexR);\n\n // Check if the requested UV is invalid.\n vec2 uv = (texCR + halfCR) / xShapeCR;\n bool lessThanZero = any(lessThan(uv, vec2(0, 0)));\n bool greaterThanOne = any(greaterThan(uv, vec2(1, 1)));\n bool outside = lessThanZero || greaterThanOne;\n if (outside) {\n continue;\n }\n\n float value = texture2D(x, uv).r;\n if (isNaN(value)) {\n gl_FragColor = vec4(value, 0, 0, 0);\n return;\n }\n if (" + (poolType === 'avg') + ") {\n avgValue += value / " + fSize * fSize + ".0;\n } else {\n // If a min / max value has already been found, use it. If not, use\n // the current value.\n float currentMinMaxValue = mix(\n value, minMaxValue, minMaxValueFound);\n if (value " + (poolType === 'min' ? '<=' : '>=') + " currentMinMaxValue) {\n minMaxValue = value;\n minMaxValueFound = 1.0;\n if (" + computePositions + ") {\n minMaxPosition = wR * " + fSize + ".0 + wC;\n }\n }\n }\n }\n }\n gl_FragColor = vec4(" + returnValue + ", 0, 0, 0);\n }"; +} +exports.getFragmentShaderPoolCommonSource = getFragmentShaderPoolCommonSource; +function poolCommon(gpgpu, program, x, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} +exports.poolCommon = poolCommon; + +},{"../conv_util":17,"./webgl_util":59}],47:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(rows, columns) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n const vec2 aDimCR = vec2(" + columns + ".0, " + rows + ".0);\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n float sum = 0.0;\n for (float r = 0.0; r < aDimCR.y; r += 1.0) {\n for (float c = 0.0; c < aDimCR.x; c += 1.0) {\n vec2 uv = (vec2(c, r) + halfCR) / aDimCR;\n sum += texture2D(matrixA, uv).r;\n }\n }\n gl_FragColor = vec4(sum, 0, 0, 0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reduceSum(gpgpu, reduceSumProgram, a, aNumRows, aNumCols, result) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.reduceSum = reduceSum; +function uploadReduceSumDownload(a, rows, columns) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadReduceSumDownload = uploadReduceSumDownload; + +},{"./gpgpu_context":36}],48:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getReluUnaryOp() { + return "\n float result = (value < 0.0 ? 0.0 : value);\n gl_FragColor = vec4(result, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function relu(gpgpu, reluProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} +exports.relu = relu; +function uploadReluDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} +exports.uploadReluDownload = uploadReluDownload; + +},{"./unaryop_gpu":58}],49:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var webgl_util = require("./webgl_util"); +function getRenderRGBShader(gpgpu, destinationWidth) { + var fragmentShaderSource = "\n precision highp float;\n uniform sampler2D source;\n varying vec2 resultUV;\n\n const float destinationWidth = " + destinationWidth + ".0;\n const float a = 1.0;\n\n void main() {\n float xr = floor(resultUV.s * destinationWidth) * 3.0;\n vec3 x = xr + vec3(0, 1, 2);\n\n float sourceWidth = destinationWidth * 3.0;\n vec3 u = (x + 0.5) / sourceWidth;\n float v = 1.0 - resultUV.t;\n\n float r = texture2D(source, vec2(u[0], v)).r;\n float g = texture2D(source, vec2(u[1], v)).r;\n float b = texture2D(source, vec2(u[2], v)).r;\n\n gl_FragColor = vec4(r, g, b, a);\n }"; + return gpgpu.createProgram(fragmentShaderSource); +} +exports.getRenderRGBShader = getRenderRGBShader; +function renderToCanvas(gpgpu, renderShader, sourceTex) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} +exports.renderToCanvas = renderToCanvas; +function renderToFramebuffer(gpgpu, renderShader, sourceTex) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} +exports.renderToFramebuffer = renderToFramebuffer; + +},{"./webgl_util":59}],50:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function getFragmentShaderSource() { + return "\n precision highp float;\n uniform sampler2D matrixA;\n uniform vec2 inputDimCR;\n uniform vec2 resultDimCR;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void main() {\n vec2 resultCR = floor(resultUV * resultDimCR);\n // indexInFlat = row * stride + column, where stride == numOutputColumns\n float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x;\n\n vec2 inputCR = vec2(\n mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns\n floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns\n ) + halfCR;\n\n vec2 inputUV = inputCR / inputDimCR;\n gl_FragColor = texture2D(matrixA, inputUV);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function reshape(gpgpu, reshapeProgram, a, aNumRows, aNumCols, result, resultNumRows, resultNumCols) { + var inputSize = aNumRows * aNumCols; + var outputSize = resultNumCols * resultNumRows; + util.assert(inputSize === outputSize, "The input size (" + inputSize + ") and output size (" + outputSize + ") " + + "must match"); + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + var inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + var resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + gpgpu.executeProgram(); +} +exports.reshape = reshape; + +},{"../../util":87}],51:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../conv_util"); +function getFragmentShaderSource(inputShapeRCD, outputDimensionsRowCol, alignCorners) { + var depth = inputShapeRCD[2]; + var inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + var effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + var effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n const vec2 inputShapeCR = vec2(" + inputShapeRCD[1] + ", " + inputShapeRCD[0] + ");\n const vec2 inputShapeTexCR = vec2(\n " + inputTexShapeRC[1] + ", " + inputTexShapeRC[0] + ");\n\n const vec2 effectiveInputOverOutputRatioCR = vec2(\n " + effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1] + ",\n " + effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0] + ");\n\n float sampleInput(float col, float row, float d) {\n vec2 uv = (vec2(col * " + depth + ".0 + d, row) + halfCR) / inputShapeTexCR;\n return texture2D(matrixA, uv).r;\n }\n\n void main() {\n vec2 yTexCR = floor(gl_FragCoord.xy);\n\n // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d).\n vec2 yCR = vec2(floor(yTexCR.x / " + depth + ".0), yTexCR.y);\n float d = mod(yTexCR.x, " + depth + ".0);\n\n // Fractional source index.\n vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR;\n\n // Compute the four integer indices.\n vec2 sourceFloorCR = floor(sourceFracIndexCR);\n vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR));\n\n float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d);\n float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d);\n float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d);\n float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d);\n\n vec2 fracCR = sourceFracIndexCR - sourceFloorCR;\n\n float top = topLeft + (topRight - topLeft) * fracCR[0];\n float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0];\n float newValue = top + (bottom - top) * fracCR[1];\n\n gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0);\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function resizeBilinear(gpgpu, resizeBilinearProgram, a, result, resultShapeRowCol) { + gpgpu.setOutputMatrixTexture(result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.resizeBilinear = resizeBilinear; + +},{"../conv_util":17}],52:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../../util"); +function makeShaderKey(inputs, output) { + var ins = inputs.map(function (x) { return x.shape + '_' + x.getTextureShapeRC(); }); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} +exports.makeShaderKey = makeShaderKey; +function makeShader(inputs, output, userCode) { + var inputPrefixSnippet = inputs.map(function (x) { return "uniform sampler2D " + x.name + ";"; }).join('\n'); + var inputSamplingSnippet = inputs.map(function (x) { return getInputSamplingSnippet(x); }).join('\n'); + var outTexShape = output.getTextureShapeRC(); + var outputSamplingSnippet = getOutputSamplingSnippet(output.shape, outTexShape); + var source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} +exports.makeShader = makeShader; +function getInputSamplingSnippet(input) { + var arr = input.array; + var shape = arr.shape; + var texShape = arr.getTextureShapeRC(shape); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape, texShape); + default: + throw new Error(arr.rank + "-D input sampling is not yet supported"); + } +} +function getOutputSamplingSnippet(outShape, outTexShape) { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape, outTexShape); + default: + throw new Error(outShape.length + "-D output sampling is not yet supported"); + } +} +var SHADER_PREFIX = "\n precision highp float;\n varying vec2 resultUV;\n const vec2 halfCR = vec2(0.5, 0.5);\n\n void setOutput(float val) {\n gl_FragColor = vec4(val, 0, 0, 0);\n }\n"; +var SAMPLE_2D_SNIPPET = "\n float sample2D(sampler2D texture, float texNumR, float texNumC, float numC,\n float row, float col) {\n float index = dot(vec2(row, col), vec2(numC, 1.0));\n float texR = floor(index / texNumC);\n float texC = mod(index, texNumC);\n vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n return texture2D(texture, uv).r;\n }\n"; +function getOutput2DCoords(shape, texShape) { + if (util.arraysEqual(shape, texShape)) { + return "\n vec2 getOutputCoords() {\n return floor(gl_FragCoord.yx);\n }\n "; + } + return "\n vec2 getOutputCoords() {\n vec2 resTexRC = floor(gl_FragCoord.yx);\n float index = dot(resTexRC, vec2(" + texShape[1] + ".0, 1.0));\n float r = floor(index / " + shape[1] + ".0);\n float c = mod(index, " + shape[1] + ".0);\n return vec2(r, c);\n }\n "; +} +function getSampler2D(texName, shape, texShape) { + var funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + var tR = texShape[0]; + var tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return "\n float " + funcName + "(float row, float col) {\n vec2 uv = (vec2(col, row) + halfCR) / vec2(" + tC + ".0, " + tR + ".0);\n return texture2D(" + texName + ", uv).r;\n }\n "; + } + return "\n float " + funcName + "(float row, float col) {\n return sample2D(" + texName + ", " + tR + ".0, " + tC + ".0, " + shape[1] + ".0, row, col);\n }\n "; +} + +},{"../../util":87}],53:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSigmoidUnaryOp() { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} +function getSigmoidFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} +exports.getSigmoidFragmentShaderSource = getSigmoidFragmentShaderSource; +function sigmoid(gpgpu, sigmoidProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} +exports.sigmoid = sigmoid; +function uploadSigmoidDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSigmoidUnaryOp()); +} +exports.uploadSigmoidDownload = uploadSigmoidDownload; + +},{"./unaryop_gpu":58}],54:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getStepUnaryOp() { + return "\n float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value;\n gl_FragColor = vec4(res, 0, 0, 0);\n "; +} +function getFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function step(gpgpu, stepProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} +exports.step = step; +function uploadStepDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} +exports.uploadStepDownload = uploadStepDownload; + +},{"./unaryop_gpu":58}],55:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function getUnpackedMatrixTextureShapeWidthHeight(rows, columns) { + return [columns, rows]; +} +exports.getUnpackedMatrixTextureShapeWidthHeight = getUnpackedMatrixTextureShapeWidthHeight; +function getUnpackedArraySizeFromMatrixSize(matrixSize, channelsPerTexture) { + return matrixSize * channelsPerTexture; +} +exports.getUnpackedArraySizeFromMatrixSize = getUnpackedArraySizeFromMatrixSize; +function getColorMatrixTextureShapeWidthHeight(rows, columns) { + return [columns * 4, rows]; +} +exports.getColorMatrixTextureShapeWidthHeight = getColorMatrixTextureShapeWidthHeight; +function getMatrixSizeFromUnpackedArraySize(unpackedSize, channelsPerTexture) { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error('unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} +exports.getMatrixSizeFromUnpackedArraySize = getMatrixSizeFromUnpackedArraySize; +function encodeMatrixToUnpackedArray(matrix, unpackedArray, channelsPerTexture) { + var requiredSize = getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error('unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} +exports.encodeMatrixToUnpackedArray = encodeMatrixToUnpackedArray; +function decodeMatrixFromUnpackedArray(unpackedArray, matrix, channelsPerTexture) { + var requiredSize = getMatrixSizeFromUnpackedArraySize(unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var dst = 0; + for (var src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} +exports.decodeMatrixFromUnpackedArray = decodeMatrixFromUnpackedArray; +function getPackedMatrixTextureShapeWidthHeight(rows, columns) { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} +exports.getPackedMatrixTextureShapeWidthHeight = getPackedMatrixTextureShapeWidthHeight; +function getPackedRGBAArraySizeFromMatrixShape(rows, columns) { + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), w = _a[0], h = _a[1]; + return w * h * 4; +} +exports.getPackedRGBAArraySizeFromMatrixShape = getPackedRGBAArraySizeFromMatrixShape; +function encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA) { + var requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error('packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + { + var dstStride = (oddWidth ? 4 : 0); + var oneRow = columns; + var dst = 0; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + var matrixSrcRow = (blockY * 2 * columns); + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + var matrixSrcCol = blockX * 2; + var src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + if (oddWidth) { + var src = columns - 1; + var dst = (textureWidth - 1) * 4; + var srcStride = 2 * columns; + var dstStride = textureWidth * 4; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (rows - 1) * columns; + var dst = (textureHeight - 1) * textureWidth * 4; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + return packedRGBA; +} +exports.encodeMatrixToPackedRGBA = encodeMatrixToPackedRGBA; +function decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix) { + var requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error('matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + var oddWidth = (columns % 2) === 1; + var oddHeight = (rows % 2) === 1; + var widthInFullBlocks = Math.floor(columns / 2); + var heightInFullBlocks = Math.floor(rows / 2); + var _a = getPackedMatrixTextureShapeWidthHeight(rows, columns), textureWidth = _a[0], textureHeight = _a[1]; + { + var srcStride = oddWidth ? 4 : 0; + var dstStride = columns + (oddWidth ? 1 : 0); + var src = 0; + var dstRow1 = 0; + var dstRow2 = columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + if (oddWidth) { + var src = (textureWidth - 1) * 4; + var dst = columns - 1; + var srcStride = textureWidth * 4; + var dstStride = 2 * columns; + for (var blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + if (oddHeight) { + var src = (textureHeight - 1) * textureWidth * 4; + var dst = (rows - 1) * columns; + for (var blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + return matrix; +} +exports.decodeMatrixFromPackedRGBA = decodeMatrixFromPackedRGBA; + +},{}],56:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TextureManager = (function () { + function TextureManager(gpgpu) { + this.gpgpu = gpgpu; + this.numUsedTextures = 0; + this.numFreeTextures = 0; + this.freeTextures = {}; + this.logEnabled = false; + this.usedTextureCount = {}; + } + TextureManager.prototype.acquireTexture = function (shapeRC) { + var shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift(); + } + this.numUsedTextures++; + this.log(); + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + }; + TextureManager.prototype.releaseTexture = function (texture, shape) { + var shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + }; + TextureManager.prototype.log = function () { + if (!this.logEnabled) { + return; + } + var total = this.numFreeTextures + this.numUsedTextures; + console.log('Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, "(" + total + ")"); + }; + TextureManager.prototype.getNumUsedTextures = function () { + return this.numUsedTextures; + }; + TextureManager.prototype.getNumFreeTextures = function () { + return this.numFreeTextures; + }; + TextureManager.prototype.dispose = function () { + for (var shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (var i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + }; + return TextureManager; +}()); +exports.TextureManager = TextureManager; +function getKeyFromTextureShape(shapeRowsCol) { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} + +},{}],57:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var unaryop_gpu = require("./unaryop_gpu"); +function getSinUnaryOp() { + return "\n gl_FragColor = vec4(sin(value), 0, 0, 0);\n "; +} +function getSinFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} +exports.getSinFragmentShaderSource = getSinFragmentShaderSource; +function sin(gpgpu, sinProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} +exports.sin = sin; +function uploadSinDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} +exports.uploadSinDownload = uploadSinDownload; +function getTanhUnaryOp() { + return "\n float e2x = exp(-2.0 * value);\n gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0);\n "; +} +function getTanhFragmentShaderSource() { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} +exports.getTanhFragmentShaderSource = getTanhFragmentShaderSource; +function tanh(gpgpu, tanhProgram, a, rows, columns, result) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} +exports.tanh = tanh; +function uploadTanhDownload(a, rows, columns) { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} +exports.uploadTanhDownload = uploadTanhDownload; + +},{"./unaryop_gpu":58}],58:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var gpgpu_context_1 = require("./gpgpu_context"); +function getFragmentShaderSource(resultOp) { + return "\n precision highp float;\n uniform sampler2D matrixA;\n varying vec2 resultUV;\n\n void main() {\n float value = texture2D(matrixA, resultUV).r;\n " + resultOp + "\n }"; +} +exports.getFragmentShaderSource = getFragmentShaderSource; +function unaryOp(gpgpu, unaryOpProgram, a, rows, columns, result) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} +exports.unaryOp = unaryOp; +function uploadUnaryOpDownload(a, rows, columns, resultOp) { + var gpgpu = new gpgpu_context_1.GPGPUContext(); + var fragmentShaderSrc = getFragmentShaderSource(resultOp); + var program = gpgpu.createProgram(fragmentShaderSrc); + var aTexture = gpgpu.createMatrixTexture(rows, columns); + var resultTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + var result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} +exports.uploadUnaryOpDownload = uploadUnaryOpDownload; + +},{"./gpgpu_context":36}],59:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var USE_WEBGL2_WHEN_AVAILABLE = false; +var WEBGL2_ENABLED = null; +var MAX_TEXTURE_SIZE = null; +var util = require("../../util"); +exports.IS_NAN_SHADER_FUNC = "\nbool isNaN(float val) {\n return val == val ? false : true;\n}\n"; +function createWebGLRenderingContext(attributes) { + var canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} +exports.createWebGLRenderingContext = createWebGLRenderingContext; +function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL1 = preferWebGL1; +function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} +exports.preferWebGL2 = preferWebGL2; +function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + if (WEBGL2_ENABLED === undefined) { + var tempCanvas = document.createElement('canvas'); + var gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + var loseContextExtension = getExtensionOrThrow(gl, 'WEBGL_lose_context'); + loseContextExtension.loseContext(); + } + else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} +exports.isWebGL2Enabled = isWebGL2Enabled; +function createWebGLRenderingContextFromCanvas(canvas, attributes) { + var gl; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes); + } + else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)); + } + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} +exports.createWebGLRenderingContextFromCanvas = createWebGLRenderingContextFromCanvas; +function callAndCheck(gl, func) { + var returnValue = func(); + checkWebGLError(gl); + return returnValue; +} +exports.callAndCheck = callAndCheck; +var webGLDebugErrorCheckingEnabled = false; +function enableDebugWebGLErrorChecking(enabled) { + webGLDebugErrorCheckingEnabled = enabled; +} +exports.enableDebugWebGLErrorChecking = enableDebugWebGLErrorChecking; +function checkWebGLError(gl) { + if (webGLDebugErrorCheckingEnabled) { + var error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} +exports.checkWebGLError = checkWebGLError; +function getWebGLErrorMessage(gl, status) { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} +exports.getWebGLErrorMessage = getWebGLErrorMessage; +function getExtensionOrThrow(gl, extensionName) { + return throwIfNull(gl, function () { return gl.getExtension(extensionName); }, 'Extension "' + extensionName + '" not supported on this browser.'); +} +exports.getExtensionOrThrow = getExtensionOrThrow; +function createVertexShader(gl, vertexShaderSource) { + var vertexShader = throwIfNull(gl, function () { return gl.createShader(gl.VERTEX_SHADER); }, 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(vertexShader, vertexShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(vertexShader); }); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} +exports.createVertexShader = createVertexShader; +function createFragmentShader(gl, fragmentShaderSource) { + var fragmentShader = throwIfNull(gl, function () { return gl.createShader(gl.FRAGMENT_SHADER); }, 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, function () { return gl.shaderSource(fragmentShader, fragmentShaderSource); }); + callAndCheck(gl, function () { return gl.compileShader(fragmentShader); }); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} +exports.createFragmentShader = createFragmentShader; +function createProgram(gl) { + return throwIfNull(gl, function () { return gl.createProgram(); }, 'Unable to create WebGLProgram.'); +} +exports.createProgram = createProgram; +function linkProgram(gl, program) { + callAndCheck(gl, function () { return gl.linkProgram(program); }); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} +exports.linkProgram = linkProgram; +function validateProgram(gl, program) { + callAndCheck(gl, function () { return gl.validateProgram(program); }); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} +exports.validateProgram = validateProgram; +function createStaticVertexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticVertexBuffer = createStaticVertexBuffer; +function createStaticIndexBuffer(gl, data) { + var buffer = throwIfNull(gl, function () { return gl.createBuffer(); }, 'Unable to create WebGLBuffer'); + callAndCheck(gl, function () { return gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW); }); + return buffer; +} +exports.createStaticIndexBuffer = createStaticIndexBuffer; +function queryMaxTextureSize(gl) { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, function () { return gl.getParameter(gl.MAX_TEXTURE_SIZE); }); + return MAX_TEXTURE_SIZE; +} +exports.queryMaxTextureSize = queryMaxTextureSize; +function getChannelsPerTexture() { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} +exports.getChannelsPerTexture = getChannelsPerTexture; +function createTexture(gl) { + return throwIfNull(gl, function () { return gl.createTexture(); }, 'Unable to create WebGLTexture.'); +} +exports.createTexture = createTexture; +function validateTextureSize(gl, width, height) { + var maxTextureSize = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + var requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + var requested = '[' + width + 'x' + height + ']'; + var max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error('Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} +exports.validateTextureSize = validateTextureSize; +function createFramebuffer(gl) { + return throwIfNull(gl, function () { return gl.createFramebuffer(); }, 'Unable to create WebGLFramebuffer.'); +} +exports.createFramebuffer = createFramebuffer; +function bindVertexBufferToProgramAttribute(gl, program, attribute, buffer, arrayEntriesPerItem, itemStrideInBytes, itemOffsetInBytes) { + var loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + var error = new Error('Unable to get attribute "' + attribute + '" on WebGLProgram.'); + error.namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, function () { return gl.bindBuffer(gl.ARRAY_BUFFER, buffer); }); + callAndCheck(gl, function () { return gl.vertexAttribPointer(loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, itemOffsetInBytes); }); + callAndCheck(gl, function () { return gl.enableVertexAttribArray(loc); }); +} +exports.bindVertexBufferToProgramAttribute = bindVertexBufferToProgramAttribute; +function bindTextureUnit(gl, texture, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, texture); }); +} +exports.bindTextureUnit = bindTextureUnit; +function unbindTextureUnit(gl, textureUnit) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, function () { return gl.activeTexture(gl.TEXTURE0 + textureUnit); }); + callAndCheck(gl, function () { return gl.bindTexture(gl.TEXTURE_2D, null); }); +} +exports.unbindTextureUnit = unbindTextureUnit; +function getProgramUniformLocationOrThrow(gl, program, uniformName) { + return throwIfNull(gl, function () { return gl.getUniformLocation(program, uniformName); }, 'uniform "' + uniformName + '" not present in program.'); +} +exports.getProgramUniformLocationOrThrow = getProgramUniformLocationOrThrow; +function bindTextureToProgramUniformSampler(gl, program, texture, uniformSamplerName, textureUnit) { + callAndCheck(gl, function () { return bindTextureUnit(gl, texture, textureUnit); }); + var samplerLocation = getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, function () { return gl.uniform1i(samplerLocation, textureUnit); }); +} +exports.bindTextureToProgramUniformSampler = bindTextureToProgramUniformSampler; +function bindCanvasToFramebuffer(gl) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, null); }); + callAndCheck(gl, function () { return gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); }); + callAndCheck(gl, function () { return gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); }); +} +exports.bindCanvasToFramebuffer = bindCanvasToFramebuffer; +function bindColorTextureToFramebuffer(gl, texture, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); }); +} +exports.bindColorTextureToFramebuffer = bindColorTextureToFramebuffer; +function unbindColorTextureFromFramebuffer(gl, framebuffer) { + callAndCheck(gl, function () { return gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); }); + callAndCheck(gl, function () { return gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0); }); +} +exports.unbindColorTextureFromFramebuffer = unbindColorTextureFromFramebuffer; +function validateFramebuffer(gl) { + var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error('Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} +exports.validateFramebuffer = validateFramebuffer; +function getFramebufferErrorMessage(gl, status) { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} +exports.getFramebufferErrorMessage = getFramebufferErrorMessage; +function throwIfNull(gl, returnTOrNull, failureMessage) { + var tOrNull = callAndCheck(gl, function () { return returnTOrNull(); }); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull; +} +function validateTextureUnit(gl, textureUnit) { + var maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + var glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + var textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} +function getTextureShapeFromLogicalShape(gl, logicalShape, preferredTexShape) { + var maxTexSize = queryMaxTextureSize(gl); + var size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + var sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert(size === sizePreferred, "Size of shape (" + size + ") must match size of " + + ("preferredShape (" + sizePreferred + ")")); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } + else if (logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape; + } + else if (logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } + else { + return util.sizeToSquarishShape(size); + } +} +exports.getTextureShapeFromLogicalShape = getTextureShapeFromLogicalShape; + +},{"../../util":87}],60:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var add_1 = require("./ops/add"); +var argmax_1 = require("./ops/argmax"); +var argmaxequals_1 = require("./ops/argmaxequals"); +var concat3d_1 = require("./ops/concat3d"); +var convolution_1 = require("./ops/convolution"); +var divide_1 = require("./ops/divide"); +var element_wise_activation_1 = require("./ops/element_wise_activation"); +var element_wise_cost_1 = require("./ops/element_wise_cost"); +var exp_1 = require("./ops/exp"); +var linear_combination_1 = require("./ops/linear_combination"); +var log_1 = require("./ops/log"); +var matmul_1 = require("./ops/matmul"); +var max_pool_1 = require("./ops/max_pool"); +var multiply_1 = require("./ops/multiply"); +var reduce_sum_1 = require("./ops/reduce_sum"); +var reshape_1 = require("./ops/reshape"); +var softmax_1 = require("./ops/softmax"); +var split_1 = require("./ops/split"); +var subtract_1 = require("./ops/subtract"); +function emitFromGraphNodes(nodes) { + var ops = []; + nodes.forEach(function (node) { return Array.prototype.push.apply(ops, emitOpFromNode(node)); }); + return ops; +} +exports.emitFromGraphNodes = emitFromGraphNodes; +function emitOpFromNode(node) { + if (node instanceof graph_1.ReshapeNode) { + return [new reshape_1.Reshape(node.inputs[graph_1.ReshapeNode.X], node.output)]; + } + else if (node instanceof graph_1.MatMulNode) { + var x1 = node.inputs[graph_1.MatMulNode.X1]; + var x2 = node.inputs[graph_1.MatMulNode.X2]; + return [new matmul_1.MatMul(x1, x2, node.output)]; + } + else if (node instanceof graph_1.Convolution2DNode) { + var w = node.inputs[graph_1.Convolution2DNode.W]; + var x = node.inputs[graph_1.Convolution2DNode.X]; + var b = node.inputs[graph_1.Convolution2DNode.B]; + return [new convolution_1.Convolution2D(w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.MaxPoolNode) { + var x = node.inputs[graph_1.MaxPoolNode.X]; + return [new max_pool_1.MaxPool(x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } + else if (node instanceof graph_1.ExpNode) { + return [new exp_1.Exp(node.inputs[graph_1.ExpNode.X], node.output)]; + } + else if (node instanceof graph_1.LogNode) { + return [new log_1.Log(node.inputs[graph_1.LogNode.X], node.output)]; + } + else if (node instanceof graph_1.ReLUNode) { + return [new element_wise_activation_1.ReLU(node.inputs[graph_1.ReLUNode.X], node.output)]; + } + else if (node instanceof graph_1.TanHNode) { + return [new element_wise_activation_1.TanH(node.inputs[graph_1.TanHNode.X], node.output)]; + } + else if (node instanceof graph_1.SigmoidNode) { + return [new element_wise_activation_1.Sigmoid(node.inputs[graph_1.SigmoidNode.X], node.output)]; + } + else if (node instanceof graph_1.SoftmaxCrossEntropyCostNode) { + var x = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.X]; + var target = node.inputs[graph_1.SoftmaxCrossEntropyCostNode.TARGET]; + return [new softmax_1.SoftmaxCrossEntropyCost(x, target, node.output)]; + } + else if (node instanceof graph_1.SoftmaxNode) { + return [new softmax_1.Softmax(node.inputs[graph_1.SoftmaxNode.X], node.output)]; + } + else if (node instanceof graph_1.MeanSquaredCostNode) { + var label = node.inputs[graph_1.MeanSquaredCostNode.LABEL]; + var prediction = node.inputs[graph_1.MeanSquaredCostNode.PREDICTION]; + return [new element_wise_cost_1.MeanSquaredCost(label, prediction, node.output)]; + } + else if (node instanceof graph_1.ArgMaxEqualsNode) { + return [new argmaxequals_1.ArgMaxEquals(node.inputs[graph_1.ArgMaxEqualsNode.X1], node.inputs[graph_1.ArgMaxEqualsNode.X2], node.output)]; + } + else if (node instanceof graph_1.ArgMaxNode) { + return [new argmax_1.ArgMax(node.x, node.output)]; + } + else if (node instanceof graph_1.FusedLinearCombinationNode) { + return [new linear_combination_1.LinearCombination(node.inputs[graph_1.FusedLinearCombinationNode.T1], node.inputs[graph_1.FusedLinearCombinationNode.T2], node.inputs[graph_1.FusedLinearCombinationNode.C1], node.inputs[graph_1.FusedLinearCombinationNode.C2], node.output)]; + } + else if (node instanceof graph_1.Concat3DNode) { + return [new concat3d_1.Concat3D(node.inputs[graph_1.Concat3DNode.X1], node.inputs[graph_1.Concat3DNode.X2], node.axis, node.output)]; + } + else if (node instanceof graph_1.SquareNode) { + return [new element_wise_activation_1.Square(node.inputs[graph_1.SquareNode.X], node.output)]; + } + else if (node instanceof graph_1.AddNode) { + return [new add_1.Add(node.inputs[graph_1.AddNode.T1], node.inputs[graph_1.AddNode.T2], node.output)]; + } + else if (node instanceof graph_1.SubtractNode) { + return [new subtract_1.Subtract(node.inputs[graph_1.SubtractNode.T1], node.inputs[graph_1.SubtractNode.T2], node.output)]; + } + else if (node instanceof graph_1.MultiplyNode) { + return [new multiply_1.Multiply(node.inputs[graph_1.MultiplyNode.T1], node.inputs[graph_1.MultiplyNode.T2], node.output)]; + } + else if (node instanceof graph_1.DivideNode) { + return [new divide_1.Divide(node.inputs[graph_1.DivideNode.T1], node.inputs[graph_1.DivideNode.T2], node.output)]; + } + else if (node instanceof graph_1.SplitNode) { + return [new split_1.Split(node.inputs[graph_1.SplitNode.X], node.outputs)]; + } + else if (node instanceof graph_1.ReduceSumNode) { + return [new reduce_sum_1.ReduceSum(node.inputs[graph_1.ReduceSumNode.X], node.output)]; + } + else if (graph_util.isInputNode(node)) { + return []; + } + else { + throw Error('Unsupported node type: ' + node.constructor.name); + } +} + +},{"./graph":8,"./graph_util":11,"./ops/add":61,"./ops/argmax":62,"./ops/argmaxequals":63,"./ops/concat3d":64,"./ops/convolution":65,"./ops/divide":66,"./ops/element_wise_activation":67,"./ops/element_wise_cost":68,"./ops/exp":69,"./ops/linear_combination":70,"./ops/log":71,"./ops/matmul":72,"./ops/max_pool":73,"./ops/multiply":74,"./ops/reduce_sum":76,"./ops/reshape":77,"./ops/softmax":78,"./ops/split":79,"./ops/subtract":80}],61:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Add = (function (_super) { + __extends(Add, _super); + function Add(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Add.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } + else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } + else { + result = math.add(x1, x2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Add.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x1Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x1Tensor, dy); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.x2Tensor, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.x2Tensor, dy); + } + } + }); + }; + Add.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Add; +}(op_1.Operation)); +exports.Add = Add; + +},{"../graph_util":11,"../math/ndarray":23,"../util":87,"./op":75}],62:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMax = (function (_super) { + __extends(ArgMax, _super); + function ArgMax(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + ArgMax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMax(x))); + }); + }; + ArgMax.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMax backprop unimplemented'); + }; + return ArgMax; +}(op_1.Operation)); +exports.ArgMax = ArgMax; + +},{"./op":75}],63:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var op_1 = require("./op"); +var ArgMaxEquals = (function (_super) { + __extends(ArgMaxEquals, _super); + function ArgMaxEquals(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + ArgMaxEquals.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + }; + ArgMaxEquals.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('ArgMaxEquals backprop unimplemented'); + }; + return ArgMaxEquals; +}(op_1.Operation)); +exports.ArgMaxEquals = ArgMaxEquals; + +},{"./op":75}],64:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var concat3d_util = require("../math/concat3d_util"); +var op_1 = require("./op"); +var Concat3D = (function (_super) { + __extends(Concat3D, _super); + function Concat3D(x1Tensor, x2Tensor, axis, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.axis = axis; + _this.yTensor = yTensor; + concat3d_util.assertConcat3DShapesMatch(x1Tensor.shape, x2Tensor.shape, axis); + return _this; + } + Concat3D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var concatResult = math.concat3D(x1, x2, _this.axis); + inferenceArrays.set(_this.yTensor, keep(concatResult)); + }); + }; + Concat3D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + throw new Error('Concat3D backprop not implemented.'); + }; + return Concat3D; +}(op_1.Operation)); +exports.Concat3D = Concat3D; + +},{"../math/concat3d_util":16,"./op":75}],65:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Convolution2D = (function (_super) { + __extends(Convolution2D, _super); + function Convolution2D(wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, zeroPad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.wTensor = wTensor; + _this.xTensor = xTensor; + _this.bTensor = bTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.outputDepth = outputDepth; + _this.stride = stride; + _this.assertWeightsShape(wTensor.shape); + _this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(_this.xTensor.shape, _this.fieldSize, _this.stride); + util.assert(util.isInt(_this.zeroPad), "The zero padding (" + _this.zeroPad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + Convolution2D.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var biases = inferenceArrays.get(this.bTensor); + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.conv2d(x, weights, biases, _this.stride, _this.zeroPad))); + }); + }; + Convolution2D.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var weights = inferenceArrays.get(this.wTensor); + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var _a = math.conv2dBackProp(x, dy, weights, _this.stride, _this.zeroPad), dw = _a.dw, db = _a.db, dx = _a.dx; + gradientArrays.set(_this.wTensor, keep(dw)); + gradientArrays.set(_this.bTensor, keep(db)); + gradientArrays.set(_this.xTensor, keep(dx)); + }); + }; + Convolution2D.prototype.assertWeightsShape = function (weightsShape) { + util.assert(weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, "weights must be of shape [" + this.fieldSize + "," + this.fieldSize + "," + + (this.xTensor.shape[2] + "," + this.outputDepth + "] but they are of") + + ("shape [" + weightsShape + "]")); + }; + return Convolution2D; +}(op_1.Operation)); +exports.Convolution2D = Convolution2D; + +},{"../math/conv_util":17,"../util":87,"./op":75}],66:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Divide = (function (_super) { + __extends(Divide, _super); + function Divide(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Divide.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } + else { + result = math.divide(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Divide.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + var x1IsScalar = util.isScalarShape(x1.shape); + var x2IsScalar = util.isScalarShape(x2.shape); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (x1IsScalar) { + var div = math.divide(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(div))); + div.dispose(); + } + else if (x2IsScalar) { + gradientArrays.set(_this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.divide(dy, x2))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var x2Squared = math.elementWiseMul(x2, x2); + var x1OverX2Squared = void 0; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } + else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } + else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + var dx2 = math.neg(x1OverX2Squared); + var dyTimesDerivative = math.elementWiseMul(dy, dx2); + if (x2IsScalar) { + gradientArrays.set(_this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + }; + return Divide; +}(op_1.Operation)); +exports.Divide = Divide; + +},{"../graph_util":11,"../util":87,"./op":75}],67:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var activation_functions_1 = require("../math/activation_functions"); +var op_1 = require("./op"); +var ElementWiseActivation = (function (_super) { + __extends(ElementWiseActivation, _super); + function ElementWiseActivation(xTensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.func = func; + return _this; + } + ElementWiseActivation.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(_this.func.output(math, x))); + }); + }; + ElementWiseActivation.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + var dydx = _this.func.der(math, x, y); + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + }; + return ElementWiseActivation; +}(op_1.Operation)); +exports.ElementWiseActivation = ElementWiseActivation; +var ReLU = (function (_super) { + __extends(ReLU, _super); + function ReLU(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.ReLUFunc()) || this; + } + return ReLU; +}(ElementWiseActivation)); +exports.ReLU = ReLU; +var TanH = (function (_super) { + __extends(TanH, _super); + function TanH(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.TanHFunc()) || this; + } + return TanH; +}(ElementWiseActivation)); +exports.TanH = TanH; +var Sigmoid = (function (_super) { + __extends(Sigmoid, _super); + function Sigmoid(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SigmoidFunc()) || this; + } + return Sigmoid; +}(ElementWiseActivation)); +exports.Sigmoid = Sigmoid; +var Square = (function (_super) { + __extends(Square, _super); + function Square(xTensor, yTensor) { + return _super.call(this, xTensor, yTensor, new activation_functions_1.SquareFunc()) || this; + } + return Square; +}(ElementWiseActivation)); +exports.Square = Square; + +},{"../math/activation_functions":15,"./op":75}],68:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var cost_functions_1 = require("../math/cost_functions"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ElementWiseCost = (function (_super) { + __extends(ElementWiseCost, _super); + function ElementWiseCost(x1Tensor, x2Tensor, yTensor, func) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + _this.func = func; + _this.oneOverNScalar = ndarray_1.Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + return _this; + } + ElementWiseCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var elementWiseCost = _this.func.cost(math, x1, x2); + var sum = math.sum(elementWiseCost); + var result = math.scalarTimesArray(_this.oneOverNScalar, sum); + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + ElementWiseCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(_this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(_this.func.der(math, x2, x1))); + } + }); + }; + ElementWiseCost.prototype.dispose = function () { + this.func.dispose(); + this.oneOverNScalar.dispose(); + }; + return ElementWiseCost; +}(op_1.Operation)); +exports.ElementWiseCost = ElementWiseCost; +var MeanSquaredCost = (function (_super) { + __extends(MeanSquaredCost, _super); + function MeanSquaredCost(x1Tensor, x2Tensor, yTensor) { + return _super.call(this, x1Tensor, x2Tensor, yTensor, new cost_functions_1.SquareCostFunc()) || this; + } + return MeanSquaredCost; +}(ElementWiseCost)); +exports.MeanSquaredCost = MeanSquaredCost; + +},{"../graph_util":11,"../math/cost_functions":19,"../math/ndarray":23,"../util":87,"./op":75}],69:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Exp = (function (_super) { + __extends(Exp, _super); + function Exp(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Exp.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.exp(x))); + }); + }; + Exp.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var y = inferenceArrays.get(this.yTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + }; + return Exp; +}(op_1.Operation)); +exports.Exp = Exp; + +},{"../graph_util":11,"./op":75}],70:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var LinearCombination = (function (_super) { + __extends(LinearCombination, _super); + function LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, outTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.c1Tensor = c1Tensor; + _this.c2Tensor = c2Tensor; + _this.outTensor = outTensor; + return _this; + } + LinearCombination.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + var c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + }; + LinearCombination.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var c1 = inferenceArrays.get(this.c1Tensor); + var c2 = inferenceArrays.get(this.c2Tensor); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + if (graph_util.shouldBackProp(_this.c1Tensor)) { + var dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(_this.c1Tensor, keep(math.sum(dotProduct1))); + } + if (graph_util.shouldBackProp(_this.c2Tensor)) { + var dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(_this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + }; + return LinearCombination; +}(op_1.Operation)); +exports.LinearCombination = LinearCombination; + +},{"../graph_util":11,"./op":75}],71:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var op_1 = require("./op"); +var Log = (function (_super) { + __extends(Log, _super); + function Log(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + return _this; + } + Log.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.log(x))); + }); + }; + Log.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.xTensor)) { + gradientArrays.set(_this.xTensor, keep(math.divide(dy, x))); + } + }); + }; + return Log; +}(op_1.Operation)); +exports.Log = Log; + +},{"../graph_util":11,"./op":75}],72:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var math_1 = require("../math/math"); +var op_1 = require("./op"); +var MatMul = (function (_super) { + __extends(MatMul, _super); + function MatMul(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + return _this; + } + MatMul.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.matMul(x1, x2))); + } + else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set(_this.yTensor, keep(math.matrixTimesVector(x1, x2))); + } + else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set(_this.yTensor, keep(math.vectorTimesMatrix(x1, x2))); + } + }); + }; + MatMul.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + var dx1 = math.matMul(dy, x2, math_1.MatrixOrientation.REGULAR, math_1.MatrixOrientation.TRANSPOSED); + gradientArrays.set(_this.x1Tensor, keep(_this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + var dx2 = math.matMul(x1, dy, math_1.MatrixOrientation.TRANSPOSED, math_1.MatrixOrientation.REGULAR); + gradientArrays.set(_this.x2Tensor, keep(_this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + }; + return MatMul; +}(op_1.Operation)); +exports.MatMul = MatMul; + +},{"../graph_util":11,"../math/math":20,"./op":75}],73:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var conv_util = require("../math/conv_util"); +var util = require("../util"); +var op_1 = require("./op"); +var MaxPool = (function (_super) { + __extends(MaxPool, _super); + function MaxPool(xTensor, yTensor, fieldSize, stride, pad) { + if (stride === void 0) { stride = 1; } + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + _this.fieldSize = fieldSize; + _this.stride = stride; + if (pad != null) { + _this.pad = pad; + } + else { + _this.pad = conv_util.computeDefaultPad(xTensor.shape, _this.fieldSize, _this.stride); + } + util.assert(util.isInt(_this.pad), "The zero padding (" + _this.pad + ") must be an integer. Change the " + + "stride and/or zero pad parameters"); + return _this; + } + MaxPool.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.maxPool(x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + MaxPool.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.maxPoolBackprop(dy, x, _this.fieldSize, _this.stride, _this.pad))); + }); + }; + return MaxPool; +}(op_1.Operation)); +exports.MaxPool = MaxPool; + +},{"../math/conv_util":17,"../util":87,"./op":75}],74:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Multiply = (function (_super) { + __extends(Multiply, _super); + function Multiply(x1Tensor, x2Tensor, yTensor) { + var _this = _super.call(this) || this; + _this.x1Tensor = x1Tensor; + _this.x2Tensor = x2Tensor; + _this.yTensor = yTensor; + util.assert(util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Multiply.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.x1Tensor); + var t2 = inferenceArrays.get(this.x2Tensor); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } + else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(_this.yTensor, keep(result)); + }); + }; + Multiply.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var x1 = inferenceArrays.get(this.x1Tensor); + var x2 = inferenceArrays.get(this.x2Tensor); + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.x1Tensor)) { + if (util.isScalarShape(_this.x1Tensor.shape)) { + var mul = math.elementWiseMul(dy, x2); + gradientArrays.set(_this.x1Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x2.shape)) { + gradientArrays.set(_this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } + else { + gradientArrays.set(_this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + if (graph_util.shouldBackProp(_this.x2Tensor)) { + if (util.isScalarShape(_this.x2Tensor.shape)) { + var mul = math.elementWiseMul(dy, x1); + gradientArrays.set(_this.x2Tensor, keep(math.sum(mul))); + } + else if (util.isScalarShape(x1.shape)) { + gradientArrays.set(_this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } + else { + gradientArrays.set(_this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + }; + return Multiply; +}(op_1.Operation)); +exports.Multiply = Multiply; + +},{"../graph_util":11,"../util":87,"./op":75}],75:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Operation = (function () { + function Operation() { + } + Operation.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { }; + Operation.prototype.dispose = function () { }; + return Operation; +}()); +exports.Operation = Operation; + +},{}],76:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var ReduceSum = (function (_super) { + __extends(ReduceSum, _super); + function ReduceSum(x, outTensor) { + var _this = _super.call(this) || this; + _this.x = x; + _this.outTensor = outTensor; + util.assertShapesMatch(outTensor.shape, []); + return _this; + } + ReduceSum.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.x); + math.scope(function (keep) { + inferenceArrays.set(_this.outTensor, keep(math.sum(x))); + }); + }; + ReduceSum.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.x)) { + return; + } + math.scope(function (keep) { + var dy = gradientArrays.get(_this.outTensor); + if (_this.ones == null) { + var xArray = inferenceArrays.get(_this.x); + _this.ones = ndarray_1.NDArray.zerosLike(xArray); + _this.ones.fill(1); + } + gradientArrays.set(_this.x, keep(math.scalarTimesArray(dy, _this.ones))); + }); + }; + return ReduceSum; +}(op_1.Operation)); +exports.ReduceSum = ReduceSum; + +},{"../graph_util":11,"../math/ndarray":23,"../util":87,"./op":75}],77:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util = require("../util"); +var op_1 = require("./op"); +var Reshape = (function (_super) { + __extends(Reshape, _super); + function Reshape(xTensor, yTensor) { + var _this = _super.call(this) || this; + _this.xTensor = xTensor; + _this.yTensor = yTensor; + var xSize = util.sizeFromShape(xTensor.shape); + var ySize = util.sizeFromShape(yTensor.shape); + util.assert(xSize === ySize, "The input size (" + xSize + ") and output size (" + ySize + ") must match"); + return _this; + } + Reshape.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var x = inferenceArrays.get(this.xTensor); + math.scope(function (keep) { + inferenceArrays.set(_this.yTensor, keep(math.reshape(x, _this.yTensor.shape))); + }); + }; + Reshape.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var dy = gradientArrays.get(this.yTensor); + math.scope(function (keep) { + gradientArrays.set(_this.xTensor, keep(math.reshape(dy, _this.xTensor.shape))); + }); + }; + return Reshape; +}(op_1.Operation)); +exports.Reshape = Reshape; + +},{"../util":87,"./op":75}],78:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("../graph"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Softmax = (function (_super) { + __extends(Softmax, _super); + function Softmax(logitsTensor, output) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.output = output; + return _this; + } + Softmax.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + return math.scope(function (keep) { + inferenceArrays.set(_this.output, keep(math.softmax(logits))); + }); + }; + Softmax.prototype.backProp = function () { + throw Error('Softmax backprop is not yet implemented'); + }; + return Softmax; +}(op_1.Operation)); +exports.Softmax = Softmax; +var SoftmaxCrossEntropyCost = (function (_super) { + __extends(SoftmaxCrossEntropyCost, _super); + function SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor) { + var _this = _super.call(this) || this; + _this.logitsTensor = logitsTensor; + _this.labelTensor = labelTensor; + _this.yTensor = yTensor; + _this.epsilon = ndarray_1.Scalar.new(1e-5); + _this.softmaxTensor = new graph_1.Tensor(logitsTensor.shape); + return _this; + } + SoftmaxCrossEntropyCost.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var logits = inferenceArrays.get(this.logitsTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + var softmaxResult = math.softmax(logits); + inferenceArrays.set(_this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set(_this.yTensor, keep(crossEntropyCost(math, softmaxResult, label, _this.epsilon))); + }); + }; + SoftmaxCrossEntropyCost.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var softmax = inferenceArrays.get(this.softmaxTensor); + var label = inferenceArrays.get(this.labelTensor); + math.scope(function (keep) { + gradientArrays.set(_this.logitsTensor, keep(math.sub(softmax, label))); + }); + }; + SoftmaxCrossEntropyCost.prototype.disposeTransientArrays = function (inferenceArrays, gradientArrays) { + inferenceArrays.disposeArray(this.softmaxTensor); + }; + SoftmaxCrossEntropyCost.prototype.dispose = function () { + this.epsilon.dispose(); + }; + return SoftmaxCrossEntropyCost; +}(op_1.Operation)); +exports.SoftmaxCrossEntropyCost = SoftmaxCrossEntropyCost; +function crossEntropyCost(math, y, target, epsilon) { + util.assert(y.size === target.size, 'The output and target must be the same size'); + return math.scope(function () { + var yPlusEps = math.scalarPlusArray(epsilon, y); + var logOutput = math.log(yPlusEps); + var tarLogOutput = math.elementWiseMul(target, logOutput); + var costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} +exports.crossEntropyCost = crossEntropyCost; + +},{"../graph":8,"../math/ndarray":23,"../util":87,"./op":75}],79:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var util = require("../util"); +var op_1 = require("./op"); +var Split = (function (_super) { + __extends(Split, _super); + function Split(input, outputs) { + var _this = _super.call(this) || this; + _this.input = input; + _this.outputs = outputs; + outputs.forEach(function (output) { + util.assertShapesMatch(input.shape, output.shape); + }); + return _this; + } + Split.prototype.feedForward = function (math, inferenceArrays) { + var inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(function (output) { + inferenceArrays.set(output, inputArray); + }); + }; + Split.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + if (!graph_util.shouldBackProp(this.input)) { + return; + } + math.scope(function (keep) { + var dx = math.add(gradientArrays.get(_this.outputs[0]), gradientArrays.get(_this.outputs[1])); + _this.outputs.slice(2).forEach(function (output) { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(_this.input, keep(dx)); + }); + }; + return Split; +}(op_1.Operation)); +exports.Split = Split; + +},{"../graph_util":11,"../util":87,"./op":75}],80:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_util = require("../graph_util"); +var ndarray_1 = require("../math/ndarray"); +var util = require("../util"); +var op_1 = require("./op"); +var Subtract = (function (_super) { + __extends(Subtract, _super); + function Subtract(t1, t2, outTensor) { + var _this = _super.call(this) || this; + _this.t1 = t1; + _this.t2 = t2; + _this.outTensor = outTensor; + util.assert(util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + return _this; + } + Subtract.prototype.feedForward = function (math, inferenceArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + math.scope(function (keep) { + var result; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } + else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } + else { + result = math.sub(t1, t2); + } + inferenceArrays.set(_this.outTensor, keep(result)); + }); + }; + Subtract.prototype.backProp = function (math, inferenceArrays, gradientArrays) { + var _this = this; + var t1 = inferenceArrays.get(this.t1); + var t2 = inferenceArrays.get(this.t2); + var dy = gradientArrays.get(this.outTensor); + math.scope(function (keep) { + if (graph_util.shouldBackProp(_this.t1)) { + if (util.isScalarShape(_this.t1.shape)) { + var sum = math.sum(dy); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t1, keep(math.divide(sum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t1, keep(dy)); + } + } + if (graph_util.shouldBackProp(_this.t2)) { + if (util.isScalarShape(_this.t2.shape)) { + var sum = math.sum(dy); + var negSum = math.neg(sum); + if (_this.dySizeScalar == null) { + _this.dySizeScalar = ndarray_1.Scalar.new(dy.size); + } + gradientArrays.set(_this.t2, keep(math.divide(negSum, _this.dySizeScalar))); + } + else { + gradientArrays.set(_this.t2, keep(math.neg(dy))); + } + } + }); + }; + Subtract.prototype.dispose = function () { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + }; + return Subtract; +}(op_1.Operation)); +exports.Subtract = Subtract; + +},{"../graph_util":11,"../math/ndarray":23,"../util":87,"./op":75}],81:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Optimizer = (function () { + function Optimizer(specifiedVariableList) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList; + } + } + return Optimizer; +}()); +exports.Optimizer = Optimizer; + +},{}],82:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function defaultCompare(a, b) { + if (a === b) { + return 0; + } + else if (a < b) { + return -1; + } + else { + return 1; + } +} +exports.defaultCompare = defaultCompare; +var PriorityQueue = (function () { + function PriorityQueue(comparator, indexObserver) { + this.comparator = comparator; + this.indexObserver = indexObserver; + this.heap = []; + } + PriorityQueue.prototype.enqueue = function (t) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + }; + PriorityQueue.prototype.dequeue = function () { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + var t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + }; + PriorityQueue.prototype.update = function (newT, index) { + var last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } + else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + }; + PriorityQueue.prototype.empty = function () { + return this.heap.length === 0; + }; + PriorityQueue.prototype.onIndexChanged = function (t, newIndex) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + }; + PriorityQueue.prototype.getParentIndex = function (index) { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + }; + PriorityQueue.prototype.getLeftChildIndex = function (index) { + var candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.getRightChildIndex = function (index) { + var candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + }; + PriorityQueue.prototype.siftUpIndex = function (index) { + var parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + }; + PriorityQueue.prototype.siftUp = function (index) { + var siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + }; + PriorityQueue.prototype.siftDownIndex = function (index) { + if (index >= this.heap.length) { + return -1; + } + var largestChildIndex = index; + var leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + var rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + }; + PriorityQueue.prototype.siftDown = function (index) { + var siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + }; + PriorityQueue.prototype.compare = function (aIndex, bIndex) { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + }; + PriorityQueue.prototype.swap = function (a, b) { + var temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + }; + return PriorityQueue; +}()); +exports.PriorityQueue = PriorityQueue; + +},{}],83:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var operation_emitter = require("./operation_emitter"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var util = require("./util"); +var FeedDictionary = (function () { + function FeedDictionary(feedEntries) { + var _this = this; + this.dict = {}; + if (feedEntries) { + feedEntries.forEach(function (entry) { return _this.dict[entry.tensor.id] = entry; }); + } + } + return FeedDictionary; +}()); +exports.FeedDictionary = FeedDictionary; +var CostReduction; +(function (CostReduction) { + CostReduction[CostReduction["NONE"] = 0] = "NONE"; + CostReduction[CostReduction["SUM"] = 1] = "SUM"; + CostReduction[CostReduction["MEAN"] = 2] = "MEAN"; +})(CostReduction = exports.CostReduction || (exports.CostReduction = {})); +var Session = (function () { + function Session(graph, math) { + this.graph = graph; + this.math = math; + this.activationArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.gradientArrayMap = new tensor_array_map_1.TensorArrayMap(); + this.runtimeCache = {}; + this.oneScalar = ndarray_1.Scalar.new(1); + } + Session.prototype.dispose = function () { + var _this = this; + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(function (key) { + var runtime = _this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(function (op) { return op.dispose(); }); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + }; + Session.prototype.evalAll = function (tensors, feedEntries) { + var _this = this; + return this.math.scope(function () { + var feed = new FeedDictionary(feedEntries); + var runtime = _this.getOrCreateRuntime(tensors, feed); + var activations = _this.activationArrayMap; + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeTransientOperationArrays(runtime.operations, _this.activationArrayMap, _this.gradientArrayMap); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + runtime.operations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + var results = tensors.map(function (x) { return activations.get(x); }); + tensors.forEach(function (x) { return activations.delete(x); }); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + return results; + }); + }; + Session.prototype.eval = function (tensor, feedEntries) { + return this.evalAll([tensor], feedEntries)[0]; + }; + Session.prototype.train = function (costTensor, feedEntries, batchSize, optimizer, costReduction) { + var _this = this; + if (costReduction === void 0) { costReduction = CostReduction.NONE; } + util.assert(util.isScalarShape(costTensor.shape), 'Cost tensor for training must be a scalar value.'); + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = ndarray_1.Scalar.new(batchSize); + } + var feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + var runtime = this.getOrCreateRuntime([costTensor], feed); + var inferenceOperations = runtime.operations; + var backPropOperations = runtime.operations.slice().reverse(); + var activations = this.activationArrayMap; + var gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + session_util.addPersistentArraysToTensorArrayMap(runtime.nodes, activations); + optimizer.beforeBatch(this.math, batchSize, runtime, activations, gradients); + return this.math.scope(function (keep, track) { + var cost = track(ndarray_1.Scalar.new(0)); + for (var i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs(runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients(runtime.nodes, gradients); + session_util.disposeTransientOperationArrays(runtime.operations, activations, gradients); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(feed, activations, _this.math); + inferenceOperations.forEach(function (op) { return op.feedForward(_this.math, activations); }); + backPropOperations.forEach(function (op) { return op.backProp(_this.math, activations, gradients); }); + optimizer.afterExample(_this.math, runtime, activations, gradients); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(feed, activations, _this.math); + cost = _this.updateCostForExample(cost, activations.get(costTensor), costReduction); + } + optimizer.afterBatch(_this.math, batchSize, runtime, activations, gradients); + return _this.updateCostForBatch(cost, costReduction); + }); + }; + Session.prototype.updateCostForExample = function (totalCost, currCost, costReduction) { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + }; + Session.prototype.updateCostForBatch = function (totalCost, costReduction) { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + }; + Session.prototype.getOrCreateRuntime = function (tensors, feed) { + var key = this.makeRuntimeCacheKey(tensors, feed); + var runtime = this.runtimeCache[key]; + if (runtime === undefined) { + var nodes = session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + var operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = { nodes: nodes, operations: operations }; + this.runtimeCache[key] = runtime; + } + return runtime; + }; + Session.prototype.makeRuntimeCacheKey = function (tensors, feed) { + return tensors.map(function (x) { return x.id; }).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + }; + return Session; +}()); +exports.Session = Session; + +},{"./math/ndarray":23,"./operation_emitter":60,"./session_util":84,"./tensor_array_map":86,"./util":87}],84:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var graph_1 = require("./graph"); +var graph_util = require("./graph_util"); +var ndarray_1 = require("./math/ndarray"); +var util = require("./util"); +function getTerminatingNodesFromFeedDictionary(feedDictionary) { + return Object.keys(feedDictionary.dict) + .map(function (tensorID) { return feedDictionary.dict[+tensorID].tensor.node; }); +} +exports.getTerminatingNodesFromFeedDictionary = getTerminatingNodesFromFeedDictionary; +function getOrderedEvaluationSetFromEvalTensor(evalTensors, feedDictionary) { + var terminatingNodes = getTerminatingNodesFromFeedDictionary(feedDictionary); + var evalNodes = evalTensors.map(function (x) { return x.node; }); + var unorderedEvaluationSet = graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + var orderedEvaluationSet = graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} +exports.getOrderedEvaluationSetFromEvalTensor = getOrderedEvaluationSetFromEvalTensor; +function addPersistentArraysToTensorArrayMap(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode || node instanceof graph_1.ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} +exports.addPersistentArraysToTensorArrayMap = addPersistentArraysToTensorArrayMap; +function getVariableNodesFromEvaluationSet(evaluationSet) { + var nodes = []; + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.VariableNode) { + nodes.push(node); + } + }); + return nodes; +} +exports.getVariableNodesFromEvaluationSet = getVariableNodesFromEvaluationSet; +function throwIfFeedDictionaryContainsNDArrays(feedDictionary) { + Object.keys(feedDictionary.dict).forEach(function (tensorID) { + if (feedDictionary.dict[+tensorID].data instanceof ndarray_1.NDArray) { + throw new Error('training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} +exports.throwIfFeedDictionaryContainsNDArrays = throwIfFeedDictionaryContainsNDArrays; +function loadInputsFromFeedDictionaryToTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + var data; + if (feedEntry.data instanceof ndarray_1.NDArray) { + data = feedEntry.data; + } + else { + var provider = feedEntry.data; + data = provider.getNextCopy(math); + } + util.assert(util.arraysEqual(feedEntry.tensor.shape, data.shape), "Error loading FeedEntry: feeding NDArray of shape " + data.shape + " " + + ("does not match Tensor (id: " + feedEntry.tensor.id + ") shape: ") + + (feedEntry.tensor.shape + ".")); + activations.set(feedEntry.tensor, data); + }); +} +exports.loadInputsFromFeedDictionaryToTensorArrayMap = loadInputsFromFeedDictionaryToTensorArrayMap; +function releaseFeedDictionaryInputsFromTensorArrayMap(batchFeed, activations, math) { + Object.keys(batchFeed.dict).forEach(function (tensorID) { + var feedEntry = batchFeed.dict[+tensorID]; + if (!(feedEntry.data instanceof ndarray_1.NDArray)) { + var provider = feedEntry.data; + var feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + activations.delete(feedEntry.tensor); + }); +} +exports.releaseFeedDictionaryInputsFromTensorArrayMap = releaseFeedDictionaryInputsFromTensorArrayMap; +function removeFeedDictionaryNodesFromEvaluationSet(feedDictionary, evaluationSet) { + var i = 0; + while (i < evaluationSet.length) { + var node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } + else { + ++i; + } + } +} +exports.removeFeedDictionaryNodesFromEvaluationSet = removeFeedDictionaryNodesFromEvaluationSet; +function disposeAndInitializeOperationOutputs(evaluationSet, tensorArrayMap) { + evaluationSet.forEach(function (node) { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} +exports.disposeAndInitializeOperationOutputs = disposeAndInitializeOperationOutputs; +function disposeAndInitializeOperationInputGradients(evaluationSet, gradients) { + evaluationSet.forEach(function (node) { + Object.keys(node.inputs).forEach(function (inputName) { + var input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} +exports.disposeAndInitializeOperationInputGradients = disposeAndInitializeOperationInputGradients; +function disposeTransientOperationArrays(operations, activations, gradients) { + operations.forEach(function (op) { return op.disposeTransientArrays(activations, gradients); }); +} +exports.disposeTransientOperationArrays = disposeTransientOperationArrays; +function throwErrorIfEvaluationSetContainsPlaceholderNodes(evaluationSet) { + evaluationSet.forEach(function (node) { + if (node instanceof graph_1.PlaceholderNode) { + var shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error('Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} +exports.throwErrorIfEvaluationSetContainsPlaceholderNodes = throwErrorIfEvaluationSetContainsPlaceholderNodes; +function addSplitNodes(nodes) { + var nodeIdToNumConsumers = []; + var nodeIdToSplitNode = {}; + nodes.forEach(function (node) { + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new graph_1.SplitNode(input.graph, inputTensor); + } + }); + }); + var newNodes = []; + nodes.forEach(function (node) { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + var splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + var keys = Object.keys(node.inputs); + keys.forEach(function (key) { + var inputTensor = node.inputs[key]; + var inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} +exports.addSplitNodes = addSplitNodes; + +},{"./graph":8,"./graph_util":11,"./math/ndarray":23,"./util":87}],85:[function(require,module,exports){ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var ndarray_1 = require("./math/ndarray"); +var optimizer_1 = require("./optimizer"); +var session_util = require("./session_util"); +var tensor_array_map_1 = require("./tensor_array_map"); +var SGDOptimizer = (function (_super) { + __extends(SGDOptimizer, _super); + function SGDOptimizer(learningRate, specifiedVariableList) { + var _this = _super.call(this, specifiedVariableList) || this; + _this.learningRate = learningRate; + _this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + _this.one = ndarray_1.Scalar.new(1); + return _this; + } + SGDOptimizer.prototype.beforeBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = ndarray_1.Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach(function (node) { return _this.variableGradients.set(node.output, ndarray_1.NDArray.zeros(node.output.shape)); }); + }; + SGDOptimizer.prototype.afterExample = function (math, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var gradient = gradientArrayMap.get(node.output); + var accumulatedGradient = _this.variableGradients.get(node.output); + _this.variableGradients.set(node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + }; + SGDOptimizer.prototype.afterBatch = function (math, batchSize, runtime, activationArrayMap, gradientArrayMap) { + var _this = this; + math.scope(function (keep) { + _this.variableNodes.forEach(function (node) { + var oldVariable = activationArrayMap.get(node.output); + var gradient = _this.variableGradients.get(node.output); + var variable = math.scaledArrayAdd(_this.c, gradient, _this.one, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + oldVariable.dispose(); + }); + }); + this.variableGradients.dispose(); + this.variableGradients = new tensor_array_map_1.TensorArrayMap(); + }; + SGDOptimizer.prototype.dispose = function () { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + }; + SGDOptimizer.prototype.setLearningRate = function (learningRate) { + this.learningRate = learningRate; + }; + return SGDOptimizer; +}(optimizer_1.Optimizer)); +exports.SGDOptimizer = SGDOptimizer; + +},{"./math/ndarray":23,"./optimizer":81,"./session_util":84,"./tensor_array_map":86}],86:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var TensorArrayMap = (function () { + function TensorArrayMap() { + this.dict = {}; + } + TensorArrayMap.prototype.set = function (tensor, array) { + this.dict[tensor.id] = array; + }; + TensorArrayMap.prototype.get = function (tensor, skipChecks) { + if (skipChecks === void 0) { skipChecks = false; } + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + var nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda; + }; + TensorArrayMap.prototype.delete = function (tensor) { + delete this.dict[tensor.id]; + }; + TensorArrayMap.prototype.disposeArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + var nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + }; + TensorArrayMap.prototype.size = function () { + return Object.keys(this.dict).length; + }; + TensorArrayMap.prototype.dispose = function () { + var _this = this; + Object.keys(this.dict).forEach(function (tensorID) { + var nda = _this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + }; + TensorArrayMap.prototype.hasNullArray = function (tensor) { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + }; + return TensorArrayMap; +}()); +exports.TensorArrayMap = TensorArrayMap; + +},{}],87:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +function shuffle(array) { + var counter = array.length; + var temp = 0; + var index = 0; + while (counter > 0) { + index = (Math.random() * counter) | 0; + counter--; + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} +exports.shuffle = shuffle; +function clamp(min, x, max) { + return Math.max(min, Math.min(x, max)); +} +exports.clamp = clamp; +function randUniform(a, b) { + return Math.random() * (b - a) + a; +} +exports.randUniform = randUniform; +function randGauss(mean, stdDev, truncated) { + if (mean === void 0) { mean = 0; } + if (stdDev === void 0) { stdDev = 1; } + if (truncated === void 0) { truncated = false; } + var v1, v2, s; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + var result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} +exports.randGauss = randGauss; +function distSquared(a, b) { + var result = 0; + for (var i = 0; i < a.length; i++) { + var diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} +exports.distSquared = distSquared; +function assert(expr, msg) { + if (!expr) { + throw new Error(msg); + } +} +exports.assert = assert; +function assertShapesMatch(shapeA, shapeB, errorMessagePrefix) { + if (errorMessagePrefix === void 0) { errorMessagePrefix = ''; } + assert(arraysEqual(shapeA, shapeB), errorMessagePrefix + ("Shapes " + shapeA + " and " + shapeB + " must match")); +} +exports.assertShapesMatch = assertShapesMatch; +function flatten(arr, ret) { + ret = (ret === undefined ? [] : ret); + for (var i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } + else { + ret.push(arr[i]); + } + } + return ret; +} +exports.flatten = flatten; +function inferShape(arr) { + var shape = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} +exports.inferShape = inferShape; +function sizeFromShape(shape) { + if (shape.length === 0) { + return 1; + } + var size = shape[0]; + for (var i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} +exports.sizeFromShape = sizeFromShape; +function isScalarShape(shape) { + return shape.length === 0; +} +exports.isScalarShape = isScalarShape; +function arraysEqual(n1, n2) { + if (n1.length !== n2.length) { + return false; + } + for (var i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} +exports.arraysEqual = arraysEqual; +function isInt(a) { + return a % 1 === 0; +} +exports.isInt = isInt; +function tanh(x) { + if (Math.tanh != null) { + return Math.tanh(x); + } + if (x === Infinity) { + return 1; + } + else if (x === -Infinity) { + return -1; + } + else { + var e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} +exports.tanh = tanh; +function sizeToSquarishShape(size) { + for (var a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} +exports.sizeToSquarishShape = sizeToSquarishShape; +function createShuffledIndices(n) { + var shuffledIndices = new Uint32Array(n); + for (var i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} +exports.createShuffledIndices = createShuffledIndices; + +},{}]},{},[2]); diff --git a/demos/polymer-spec.ts b/demos/polymer-spec.ts new file mode 100644 index 0000000000..1664cb4385 --- /dev/null +++ b/demos/polymer-spec.ts @@ -0,0 +1,64 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +/** + * @fileoverview + * + * Defines an interface for creating Polymer elements in Typescript with the + * correct typings. A Polymer element should be defined like this: + * + * ``` + * let MyElementPolymer = PolymerElement({ + * is: 'my-polymer-element', + * properties: { + * foo: string, + * bar: Array + * } + * }); + * + * class MyElement extends MyElementPolymer { + * foo: string; + * bar: number[]; + * + * ready() { + * console.log('MyElement initialized!'); + * } + * } + * + * document.registerElement(MyElement.prototype.is, MyElement); + * ``` + */ + +export type Spec = { + is: string; properties: { + [key: string]: (Function|{ + // tslint:disable-next-line:no-any + type: Function, value?: any; + reflectToAttribute?: boolean; + readonly?: boolean; + notify?: boolean; + computed?: string; + observer?: string; + }) + }; + observers?: string[]; +}; + +export function PolymerElement(spec: Spec) { + // tslint:disable-next-line:no-any + return Polymer.Class(spec as any) as {new (): PolymerHTMLElement}; +} + +export interface PolymerHTMLElement extends HTMLElement, polymer.Base {} diff --git a/demos/xhr-dataset.ts b/demos/xhr-dataset.ts new file mode 100644 index 0000000000..6e7833d311 --- /dev/null +++ b/demos/xhr-dataset.ts @@ -0,0 +1,195 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {InMemoryDataset} from '../src/dataset'; +import {Array1D, NDArray} from '../src/math/ndarray'; +import * as util from '../src/util'; + +const PARSING_IMAGE_CANVAS_HEIGHT_PX = 1000; + +export interface NDArrayInfo { + path: string; + name: string; + dataType: 'uint8'|'float32'|'png'; + shape: number[]; +} + +export interface XhrDatasetConfig { + data: NDArrayInfo[]; + + labelClassNames?: string[]; + // Paths to pre-built models. + modelConfigs: {[modelName: string]: XhrModelConfig}; +} + +export interface XhrModelConfig { + path: string; +} + +export function getXhrDatasetConfig(jsonConfigPath: string): + Promise<{[datasetName: string]: XhrDatasetConfig}> { + return new Promise<{[datasetName: string]: XhrDatasetConfig}>( + (resolve, reject) => { + const xhr = new XMLHttpRequest(); + xhr.open('GET', jsonConfigPath); + + xhr.onload = () => { + resolve(JSON.parse( + xhr.responseText) as {[datasetName: string]: XhrDatasetConfig}); + }; + xhr.onerror = (error) => { + reject(error); + }; + xhr.send(); + }); +} + +export class XhrDataset extends InMemoryDataset { + protected xhrDatasetConfig: XhrDatasetConfig; + + constructor(xhrDatasetConfig: XhrDatasetConfig) { + super(xhrDatasetConfig.data.map(x => x.shape)); + this.xhrDatasetConfig = xhrDatasetConfig; + } + + protected getNDArray(info: NDArrayInfo): Promise { + const dataPromise = info.dataType === 'png' ? + parseTypedArrayFromPng(info, info.shape as [number, number, number]) : + parseTypedArrayFromBinary(info); + + return dataPromise.then(data => { + const inputSize = util.sizeFromShape(info.shape); + const ndarrays: T[] = []; + for (let i = 0; i < data.length / inputSize; i++) { + const values = data.subarray(i * inputSize, (i + 1) * inputSize); + const ndarray = + NDArray.make(info.shape, {values: new Float32Array(values)}); + ndarrays.push(ndarray); + } + return ndarrays; + }); + } + + fetchData(): Promise { + return new Promise((resolve, reject) => { + const promises = this.xhrDatasetConfig.data.map(x => this.getNDArray(x)); + Promise.all(promises).then((data: NDArray[][]) => { + this.dataset = data; + resolve(); + }); + }); + } +} + +function parseTypedArrayFromBinary(info: NDArrayInfo): + Promise { + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); + xhr.open('GET', info.path); + xhr.responseType = 'arraybuffer'; + xhr.onload = event => { + const data = (info.dataType === 'float32') ? + new Float32Array(xhr.response) : + new Uint8Array(xhr.response); + resolve(data); + }; + xhr.onerror = err => reject(err); + xhr.send(); + }); +} + +function parseGrayscaleImageData( + data: Uint8Array|Uint8ClampedArray, result: Uint8Array, + resultOffset: number): void { + let idx = resultOffset; + for (let i = 0; i < data.length; i += 4) { + result[idx++] = data[i]; + } +} + +function parseRGBImageData( + data: Uint8Array|Uint8ClampedArray, result: Uint8Array, + resultOffset: number): void { + let idx = resultOffset; + for (let i = 0; i < data.length; i += 4) { + result[idx] = data[i]; + result[idx + 1] = data[i + 1]; + result[idx + 2] = data[i + 2]; + idx += 3; + } +} + +function parseImage( + img: HTMLImageElement, shape: [number, number, number]): Uint8Array { + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d')!; + const N = img.height; + const inputSize = util.sizeFromShape(shape); + const result = new Uint8Array(N * inputSize); + if (img.width !== shape[0] * shape[1]) { + throw new Error( + `Image width (${img.width}) must be multiple of ` + + `rows*columns (${shape[0]}*${shape[1]}) of the ndarray`); + } + // TODO(smilkov): Canvas has max width of 32,767px. This approach + // (canvas.width = shape[0] * shape[1]) works with examples up to 181x181px. + // Consider having the canvas in un-flat format, i.e. + // canvas.width = shape[1]; canvas.height = DRAW_BATCH * shape[0]; + canvas.width = img.width; + + // Ideally we want canvas.height=img.height (which is N), but canvas size is + // limited by the browser, so we do multiple passes with a smaller canvas. + canvas.height = PARSING_IMAGE_CANVAS_HEIGHT_PX; + const sx = 0; + const sWidth = canvas.width; + let sHeight = canvas.height; + const dx = 0; + const dy = 0; + const dWidth = sWidth; + let dHeight = sHeight; + const depth = shape[2]; + let offset = 0; + const numPasses = Math.ceil(N / canvas.height); + for (let pass = 0; pass < numPasses; ++pass) { + const sy = pass * canvas.height; + if ((pass === numPasses - 1) && (N % canvas.height > 0)) { + // Last pass is a special case. + canvas.height = N % canvas.height; + sHeight = canvas.height; + dHeight = sHeight; + } + ctx.drawImage(img, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight); + const data = ctx.getImageData(0, 0, canvas.width, canvas.height).data; + (depth === 1) ? parseGrayscaleImageData(data, result, offset) : + parseRGBImageData(data, result, offset); + offset += canvas.height * inputSize; + } + return result; +} + +function parseTypedArrayFromPng( + info: NDArrayInfo, shape: [number, number, number]): Promise { + return new Promise((resolve, reject) => { + let img = new Image(); + img.setAttribute('crossOrigin', ''); + img.onload = () => { + const result = parseImage(img, shape); + img.src = ''; + img = null!; + resolve(result); + }; + img.src = info.path; + }); +} diff --git a/docs/roadmap.md b/docs/roadmap.md new file mode 100644 index 0000000000..06af868851 --- /dev/null +++ b/docs/roadmap.md @@ -0,0 +1,72 @@ +--- +layout: page +order: 1000 +--- +# Roadmap + +This page outlines some of the projects we wish to happen in the near future. +These are projects that we would love to see the open source community +contribute to. + +## Optimizers + +Currently, **deeplearn.js** only has an SGD optimizer, however the optimizer +interface is generic enough to support new optimizers. We would love to see: + + * RMSProp + * Adagrad + * Adadelta + * Adam + * Adamax + +## Logical sampling + +When writing custom shader programs in **deeplearn.js**, the author must sample +textures in 2D physical texture space. This means that if an shader program +operates on an `Array3D`, it must manually convert between logical 3D space and +physical 2D texture space. Since shader programs are a little tricky to debug, +this makes shader programs error-prone. + +We have started on "logical sampling", that is, introducing functions and a +shader compiler that allows shaders to sample in logical space through a utility +function. This means we can store higher dimensional NDArrays in 2D textures in +whatever shape we want to ensure minimal reshapes when chaining operations. + +Currently, matmul is the only GPU shader program that uses the new shader compiler +and logical sampling, but it should serve as a guide for the way shader programs +should be migrated, and how new shader programs should be written. + +## Batch as the outer dimension + +**deeplearn.js** at the shader level only supports operations with a batch size +of 1, whereas most other machine learning libraries use the batch size as an +outer dimension. This is usually okay for many applications, though it can be +restrictive when models are ported. + +As part of the new shader compiler and helper functions to do logical sampling, +we now can introduce batching as an outer dimension of operations. + +## Automatic TensorFlow <=> deeplearn.js + +Currently we support dumping weights from a TensorFlow checkpoint into a format +that can be imported into **deeplearn.js**, however the developer must then +recreate the model in **deeplearn.js** and use the weights from that checkpoint. + +We plan on building a way to port models directly from TensorFlow => +**deeplearn.js** automatically from a `GraphDef`. + +## Dynamic batching + +Dynamic batching, which allows training with explicitly defining a graph, but +instead simply analyzing the forward mathematical operations and differentiating +that dynamic computation graph, is a popular method for training models. + +We can implement dynamic batching by doing it at the NDArrayMath layer. When +mathematical methods are called, we can record operations that were called and +automatically differentiate when requested. + +## Recurrence in training + +**deeplearn.js** doesn't currently support recurrence as top level +functionality during training, however we do support arbitrary data flow graphs, +so recurrence should be straight forward to implement. diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md new file mode 100644 index 0000000000..e3713a7c1c --- /dev/null +++ b/docs/tutorials/index.md @@ -0,0 +1,24 @@ +--- +layout: page +title: '' +--- +# Tutorials + +This is a living, breathing document. Feel free to add your work below. + +{% assign default_paths = site.pages | map: "path" %} +{% assign page_paths = site.header_pages | default: default_paths %} + + diff --git a/docs/tutorials/intro.md b/docs/tutorials/intro.md new file mode 100644 index 0000000000..f95731d6c5 --- /dev/null +++ b/docs/tutorials/intro.md @@ -0,0 +1,310 @@ +--- +layout: page +order: 2 +--- +# Introduction + +**deeplearn.js** is an open source WebGL-accelerated JavaScript library for machine +intelligence. **deeplearn.js** brings highly performant machine learning +building blocks to your fingertips, allowing you to train neural networks +in a browser or run pre-trained models in inference mode. It provides an API for +constructing differentiable data flow graphs, as well as a set of mathematical +functions that can be used directly. + +* TOC +{:toc} + +For the purposes of the documentation, we will use TypeScript code examples. +For vanilla JavaScript, you may need to remove TypeScript syntax like +`const`, `let`, or other type definitions. + +## Core concepts + +### NDArrays + +The central unit of data in **deeplearn.js** is the `NDArray`. An `NDArray` +consists of a set of floating point values shaped into an array of an arbitrary +number of dimensions. `NDArray`s have a `shape` attribute to define +their shape. The library provides sugar subclasses for low-rank `NDArray`s: +`Scalar`, `Array1D`, `Array2D`, `Array3D` and `Array4D`. + +Example usage with a 2x3 matrix: + +```js +const shape = [2, 3]; // 2 rows, 3 columns +const a = Array2D.new(shape, [1.0, 2.0, 3.0, 10.0, 20.0, 30.0]); +``` + +`NDArray`s can store data either on the GPU as a `WebGLTexture`, where each +pixel stores a floating point value, or on the CPU as a vanilla JavaScript +`TypedArray`. Most of the time, the user should not think about the storage, +as it is an implementation detail. + +If `NDArray` data is +stored on the CPU, the first time a GPU mathematical operation is called the +data will be uploaded to a texture automatically. If you call +`NDArray.getValues()` on a GPU-resident `NDArray`, the +library will download the texture to the CPU and delete the texture. + +### NDArrayMath + +The library provides a `NDArrayMath` base class which defines a set of +mathematical functions that operate on `NDArray`s. + +#### NDArrayMathGPU + +When using the `NDArrayMathGPU` implementation, these mathematical +operations enqueue shader programs to be executed on the GPU. Unlike in +`NDArrayMathCPU`, **these operations are not blocking**, but the user can +synchronize the cpu with the gpu by calling `get()` or `getValues()` on +the `NDArray`, as we describe in detail below. + +These shaders read and write from `WebGLTexture`s which are owned by +`NDArray`s. When chaining mathematical operations, textures can stay in GPU +memory (not downloaded to the CPU between operations), which is critical for +performance. + +Example of taking the mean squared difference between two matrices (more +details about `math.scope`, `keep`, and `track` below): + +```js +const math = new NDArrayMathGPU(); + +math.scope((keep, track) => { + const a = track(Array2D.new([2, 2], [1.0, 2.0, 3.0, 4.0])); + const b = track(Array2D.new([2, 2], [0.0, 2.0, 4.0, 6.0])); + + // Non-blocking math calls. + const diff = math.sub(a, b); + const squaredDiff = math.elementWiseMul(diff, diff); + const sum = math.sum(squaredDiff); + const size = Scalar.new(a.size); + const average = math.divide(sum, size); + + // Blocking call to actually read the values from average. Waits until the + // GPU has finished executing the operations before returning values. + console.log(average.get()); // average is a Scalar so we use .get() +}); +``` + +> NOTE: `NDArray.get()` and `NDArray.getValues()` are blocking calls. +There is no need to register callbacks after performing chained math functions, +just call `getValues()` to synchronize the CPU & GPU. + +> TIP: Avoid calling `get()` or `getValues()` between mathematical GPU +operations unless you are debugging. This forces a texture download, and +subsequent `NDArrayMathGPU` calls will have to re-upload the data to a new +texture. + +##### math.scope() + +When math operations are used, you must wrap them in a math.scope() function +closure as shown in the example above. The results of math operations in this +scope will get disposed at the end of the scope, unless they are the value +returned in the scope. + +Two functions are passed to the function closure, `keep()` and `track()`. + +`keep()` ensures that the NDArray passed to keep will not be cleaned up +automatically when the scope ends. + +`track()` tracks any NDArrays that you may construct directly inside of a +scope. When the scope ends, any manually tracked `NDArray`s will get +cleaned up. Results of all `math.method()` functions, as well as results of +many other core library functions are automatically cleaned up, so you don't +have to manually track them. + +```ts +const math = new NDArrayMathGPU(); + +let output; + +// You must have an outer scope, but don't worry, the library will throw an +// error if you don't have one. +math.scope((keep, track) => { + // CORRECT: By default, math wont track NDArrays that are constructed + // directly. You can call track() on the NDArray for it to get tracked and + // cleaned up at the end of the scope. + const a = track(Scalar.new(2)); + + // INCORRECT: This is a texture leak!! + // math doesn't know about b, so it can't track it. When the scope ends, the + // GPU-resident NDArray will not get cleaned up, even though b goes out of + // scope. Make sure you call track() on NDArrays you create. + const b = Scalar.new(2); + + // CORRECT: By default, math tracks all outputs of math functions. + const c = math.neg(math.exp(a)); + + // CORRECT: d is tracked by the parent scope. + const d = math.scope(() => { + // CORRECT: e will get cleaned up when this inner scope ends. + const e = track(Scalar.new(3)); + + // CORRECT: The result of this math function is tracked. Since it is the + // return value of this scope, it will not get cleaned up with this inner + // scope. However, the result will be tracked automatically in the parent + // scope. + return math.elementWiseMul(e, e); + }); + + // CORRECT, BUT BE CAREFUL: The output of math.tanh will be tracked + // automatically, however we can call keep() on it so that it will be kept + // when the scope ends. That means if you are not careful about calling + // output.dispose() some time later, you might introduce a texture memory + // leak. A better way to do this would be to return this value as a return + // value of a scope so that it gets tracked in a parent scope. + output = keep(math.tanh(d)); +}); +``` + +> More technical details: When WebGL textures go out of scope in JavaScript, +they don't get cleaned up automatically by the browser's garbage collection +mechanism. This means when you are done with an NDArray that is GPU-resident, +it must manually be disposed some time later. If you forget to manually call +`ndarray.dispose()` when you are done with an NDArray, you will introduce +a texture memory leak, which will cause serious performance issues. +If you use `math.scope()`, any NDArrays created by `math.method()` and +any other method that returns the result through a scope will automatically +get cleaned up. + + +> If you want to do manual memory management and not use math.scope(), you can +construct a `NDArrayMath` object with safeMode = false. This is not +recommended, but is useful for `NDArrayMathCPU` since CPU-resident memory +will get cleaned up automatically by the JavaScript garbage collector. + + +#### NDArrayMathCPU + +When using CPU implementations, these mathematical +operations are blocking and get executed immediately on the underlying +`TypedArray`s with vanilla JavaScript. + +### Training + +Differentiable data flow graphs in **deeplearn.js** use a delayed execution model, +just like in TensorFlow. Users construct a graph and then train or +infer on them by providing input `NDArray`s through `FeedEntry`s. + +> NOTE: NDArrayMath and NDArrays are sufficient for inference mode. You only need a +graph if you want to train. + +#### Graphs and Tensors +The `Graph` object is the core class for constructing data flow graphs. +`Graph` objects don't actually hold `NDArray` data, only connectivity +between operations. + +The `Graph` class has differentiable operations as top level member +functions. When you call a graph method to add an operation, you get back a +`Tensor` object which only holds connectivity and shape information. + +An example graph that multiplies an input by a variable: + +```js +const g = new Graph(); + +// Placeholders are input containers. This is the container for where we will +// feed an input NDArray when we execute the graph. +const inputShape = [3]; +const inputTensor = g.placeholder('input', inputShape); + +const labelShape = [1]; +const inputTensor = g.placeholder('label', labelShape); + +// Variables are containers that hold a value that can be updated from training. +// Here we initialize the multiplier variable randomly. +const multiplier = g.variable('multiplier', Array2D.randNormal([1, 3])); + +// Top level graph methods take Tensors and return Tensors. +const outputTensor = g.matmul(multiplier, inputTensor); +const costTensor = g.meanSquaredCost(outputTensor, labelTensor); + +// Tensors, like NDArrays, have a shape attribute. +console.log(outputTensor.shape); +``` + +#### Session and FeedEntry + +Session objects are what drive the execution of `Graph`s. `FeedEntry` +(similar to TensorFlow `feed_dict`) are what provide data for the run, +feeding a value to a `Tensor` from a given NDArray. + +> A quick note on batching: **deeplearn.js** hasn't yet implemented batching as an outer +dimension for operations. This means every top level graph op, as well as math +function, operate on single examples. However, batching is important so that +weight updates operate on the average of gradients over a batch. **deeplearn.js** +simulates batching by using an `InputProvider` in train `FeedEntry`s to +provide inputs, rather than `NDArray`s directly. The `InputProvider` +will get called for each item in a batch. We provide a +`InMemoryShuffledInputProviderBuilder` for shuffling a set of inputs and +keeping them in sync. + +Training with the `Graph` object from above: + +```js +const learningRate = .001; +const batchSize = 2; + +const math = new NDArrayMathGPU(); +const session = new Session(g, math); +const optimizer = new SGDOptimizer(learningRate); + +const inputs: Array1D[] = [ + Array1D.new([1.0, 2.0, 3.0]), + Array1D.new([10.0, 20.0, 30.0]), + Array1D.new([100.0, 200.0, 300.0]) +]; + +const labels: Array1D[] = [ + Array1D.new([2.0, 6.0, 12.0]), + Array1D.new([20.0, 60.0, 120.0]), + Array1D.new([200.0, 600.0, 1200.0]) +]; + +// Shuffles inputs and labels and keeps them mutually in sync. +const shuffledInputProviderBuilder = + new InCPUMemoryShuffledInputProviderBuilder([inputs, labels]); +const [inputProvider, labelProvider] = + shuffledInputProviderBuilder.getInputProviders(); + +// Maps tensors to InputProviders. +const feedEntries: FeedEntry[] = [ + {tensor: inputTensor, data: inputProvider}, + {tensor: labelTensor, data: labelProvider} +]; + +// Wrap session.train in a scope so the cost gets cleaned up automatically. +math.scope(() => { + // Train takes a cost tensor to minimize. Trains one batch. Returns the + // average cost as a Scalar. + const cost = session.train( + costTensor, feedEntries, batchSize, optimizer, CostReduction.MEAN); + + console.log('last average cost: ' + cost.get()); +}); +``` + +After training, we can infer through the graph: + +```js + +// Wrap session.eval in a scope so the intermediate values get cleaned up +// automatically. +math.scope((keep, track) => { + const testInput = track(Array1D.new([1.0, 2.0, 3.0])); + + // session.eval can take NDArrays as input data. + const testFeedEntries: FeedEntry[] = [ + {tensor: inputTensor, data: testInput} + ]; + + const testOutput = session.eval(outputTensor, testFeedEntries); + + console.log('inference output:'); + console.log(testOutput.shape); + console.log(testOutput.getValues()); +}); +``` + +Want to learn more? Read [these tutorials](index.md). diff --git a/docs/tutorials/ml_beginners.md b/docs/tutorials/ml_beginners.md new file mode 100644 index 0000000000..134f558013 --- /dev/null +++ b/docs/tutorials/ml_beginners.md @@ -0,0 +1,303 @@ +--- +layout: page +order: 3 +--- +# Guide for non-ML experts + +* TOC +{:toc} + +### NDArrays, Tensors, and numbers + +#### Mathematical tensors + +Mathematically, a "tensor" is the most basic object of linear algebra, a +generalization of numbers, vectors, and matrices. A vector can be thought of as +a 1-dimensional list of numbers; a matrix as a 2-dimensional list of numbers. A +tensor simply generalizes that concept to n-dimensional lists of numbers. It is +any arrangement of component numbers (or even strings or other data types) +arranged in any multi-dimensional rectangular array. + +A tensor has several properties: + +* It has a type, which describes the types of each of its components, + for instance `integer`, `float`, etc. **deeplearn.js** only supports + `float32` for now. +* It has a shape, a list of integers which describes the shape of the + rectangular array of components. When you say a matrix is "4 by 4", you are + describing the shape of the matrix. +* It has a rank, which is the length of its shape; the dimension of the + array of components. A vector has rank 1; a matrix has rank 2. + +Example tensor | Type | Shape | Rank +------------------ | ----- | -------- | ---- +Scalar: 3.0 | float | \[\] | 0 +Vector: (1, 5, -2) | int | \[3\] | 1 +2x2 Matrix | int | \[2, 2\] | 2 + +#### number[], NDArray, Tensor: Three data types for mathematical tensors + +This same object a mathematician would call a "tensor" is represented in three +different ways in **deeplearn.js**. The above discussion (ranks, shapes, and +types), applies to all of them, but they are different and it is important to +keep them straight: + +* `number[]` is the underlying javascript type corresponding to an + array of numbers. Really it is `number` for a 0-rank tensor, `number[]` for + a 1-rank tensor, `number[][]` for 2-rank, etc. You won't use it much within + **deeplearn.js**, but it is the way you will get things in and out of + **deeplearn.js**. +* `NDArray` is **deeplearn.js**'s more powerful implementation. + Calculations involving NDArrays can be performed on the client's GPU, which + is the fundamental advantage of **deeplearn.js**. This is the format most + actual tensor data will be in when the calculations ultimately happen. When + you call `Session.eval`, for instance, this is what you get back (and what + the `FeedEntry` inputs should be). You can convert between `NDArray` and + `number[]` using `NDArray.new(number[])` and `NDArray.get([indices])` +* `Tensor` is an empty bag; it has no actual data inside. It is a + placeholder used when a Graph is constructed, which records the shape and + type of the data that will ultimately fit inside it. It contains no actual + values in its components. Just by knowing the shape and type, however, it + can do important error-catching at Graph-construction time; if you want to + multiply a 2x3 matrix by a 10x10 matrix, the graph can yell at you when you + create the node, before you ever give it input data. It does not make sense + to convert directly between a `Tensor` and an `NDArray` or `number[]`; if + you find you are trying to do that, one of the following is probably true: + * You have a static `NDArray` that you want to use in a graph; use + graph.constant() to create a constant ```Tensor``` node. + * You have an `NDArray` that you want to feed in as an input to the Graph. + Create a Placeholder with ```graph.placeholder``` in the graph, and then + send your input to the graph in the `FeedEntry`. + * You have an output tensor and you want the session to evaluate and + return its value. Call `Session.eval(tensor)`. + + +In general, you should only use a `Graph` when you want automatic +differentiation (training). If you just want to use the library for forward +mode inference, or just general numeric computation, using `NDArray`s with +`NDArrayMath` will suffice. + +If you are interested in training, you must use a `Graph`. When you +construct a graph you will be working with `Tensor`s, and when you execute it +with `Session.eval`, the result will be `NDArray`s. + +### Forward mode inference / numeric computation + +If you just want to perform mathematical operations on NDArrays, you can simply +construct `NDArray`s with your data, and perform operations on them with +a `NDArrayMath` object. + +For example, if you want to compute a matrix times a vector on the GPU: +```ts +const math = new NDArrayMathGPU(); + +math.scope((keep, track) => { + const matrixShape = [2, 3]; // 2 rows, 3 columns. + const matrix = track(Array2D.new(matrixShape, [10, 20, 30, 40, 50, 60])); + const vector = track(Array1D.new([0, 1, 2])); + const result = math.matrixTimesVector(matrix, vector); + + console.log("result shape:", result.shape); + console.log("result", result.getValues()); +}); +``` + +For more information on `NDArrayMath`, `keep`, and `track`, see +[Introduction and core concepts](intro.md). + +The `NDArray`/`NDArrayMath` layer can be thought of as analogous to +[NumPy](http://www.numpy.org/). + +### Training: delayed execution, Graphs, and Sessions + +The most important thing to understand about training +(automatic differentiation) in **deeplearn.js** is that it uses a delayed +execution model. Your code will contain two separate stages: first you will +build a `Graph`, the object representing the calculation you want to do, then +later you will execute the graph and get the results. + +Most of the time, your `Graph` will transform some input(s) to some output(s). +In general, the architecture of your `Graph` will stay fixed, but it will +contain parameters that will be automatically updated. + +When you execute a `Graph`, there are two modes: training, and inference. + +Inference is the act of providing a `Graph` an input to produce an output. + +Training a graph involves providing the `Graph` many examples of labeled +input / output pairs, and automatically updating parameters of the `Graph` +so that the output of the `Graph` when evaluating (inferring) an input is +closer to the labelled output. The function that gives a `Scalar` representing +how close labelled output to a generated output is called the "cost function" +(also known as a "loss function"). The loss function should output close to +zero when the model is performing well. You must provide a cost function when +training. + +**deeplearn.js** is structured very similarly to +[Tensorflow](https://www.tensorflow.org), Google's python-based machine +learning language. If you know TensorFlow, the concepts of `Tensor`s, `Graph`s, +and `Session`s are all almost the same, however we assume no knowledge of +TensorFlow here. + +#### Graphs as Functions + +The difference can be understood by analogy to regular JavaScript code. For the +rest of this tutorial, we will be working with this quadratic equation: + +```ts +// y = a * x^2 + b * x + c +const x = 4; +const a = Math.random(); +const b = Math.random(); +const c = Math.random(); + +const order2 = a * Math.pow(x, 2); +const order1 = b * x; +const y = order2 + order1 + c; +``` + +In this original code, the mathematical calculations are evaluated in each line +as it's processed immediately. + +Contrast that with the following code, analogous to how **deeplearn.js** +`Graph` inference works. + +```ts +function graph(x, a, b, c) { + const order2 = a * Math.pow(x, 2); + const order1 = b * x; + return order2 + order1 + c; +} + +const a = Math.random(); +const b = Math.random(); +const c = Math.random(); +const y = graph(4, a, b, c); +``` + +This code is in two blocks: first setting up the graph function, and then +calling it. The code to set up the graph function in the first few lines does +not do any actual mathematical operations until the function is called in the +final line. During the setup, basic compiler type-safety errors can be caught +even though the calculations are not yet performed. + +This is exactly analogous to how `Graph`s work in **deeplearn.js**. The first +part of your code will set up the graph, describing: + + * Inputs, in our case "x". Inputs are represented as placeholders + (e.g. `graph.placeholder()`). + * Outputs, in our case "order1", "order2", and the final output "y". + * Operations to produce outputs, in our case the decomponsed functions of the + quadratic (x^2, multiplication, addition). + * Updatable parameters, in our case "a", "b", "c". Updatable parameters are + represented as variables (e.g. `graph.variable()`) + + +Then in a later part of your code you will "call" (`Session.eval`) the graph's +function on certain inputs, and you will learn the values for "a", "b", and +"c", for some data with `Session.train`. + +One minor difference between the above function analogy and **deeplearn.js** +`Graph`s is that the `Graph` does not specify its output. Instead, the caller +of the `Graph` function specifies which of the tensors they want to be +returned. This allows different calls to the same `Graph` to execute different +parts of it. Only the parts necessary to obtain the results demanded by the +caller will be evaluated. + +Inference and training of a `Graph` is driven by a `Session` object. This +object contains runtime state, weights, activations, and gradients +(derivatives), whereas the `Graph` object only holds connectivity information. + +So the function above would be implemented in **deeplearn.js** as follows: + +```ts +const graph = new Graph(); +// Make a new input in the graph, called 'x', with shape [] (a Scalar). +const x: Tensor = graph.placeholder('x', []); +// Make new variables in the graph, 'a', 'b', 'c' with shape [] and random +// initial values. +const a: Tensor = graph.variable('a', Scalar.new(Math.random())); +const b: Tensor = graph.variable('b', Scalar.new(Math.random())); +const c: Tensor = graph.variable('c', Scalar.new(Math.random())); +// Make new tensors representing the output of the operations of the quadratic. +const order2: Tensor = graph.multiply(a, graph.square(x)); +const order1: Tensor = graph.multiply(b, x); +const y: Tensor = graph.add(graph.add(order2, order1), c); + +// When training, we need to provide a label and a cost function. +const yLabel: Tensor = graph.placeholder('y label', []); +// Provide a mean squared cost function for training. cost = (y - yLabel)^2 +const cost: Tensor = graph.meanSquaredCost(y, yLabel); + +// At this point the graph is set up, but has not yet been evaluated. +// **deeplearn.js** needs a Session object to evaluate a graph. +const math = new NDArrayMathGPU(); +const session = new Session(graph, math); + +math.scope((keep, track) => { + /** + * Inference + */ + // Now we ask the graph to evaluate (infer) and give us the result when + // providing a value 4 for "x". + // NOTE: "a", "b", and "c" are randomly intialized, so this will give us + // something random. + const result: NDArray = + session.eval(y, [{tensor: x, data: track(Scalar.new(4))}]); + + /** + * Training + */ + // Now let's learn the coeffiecients of this quadratic given some data. + // To do this, we need to provide examples of x and y. + // The values given here are for values a = 3, b = 2, c = 1, with random + // noise added to the output so it's not a perfect fit. + const xs: Scalar[] = [ + track(Scalar.new(0)), + track(Scalar.new(1)), + track(Scalar.new(2)), + track(Scalar.new(3)) + ]; + const ys: Scalar[] = [ + track(Scalar.new(1.1)), + track(Scalar.new(5.9)), + track(Scalar.new(16.8)), + track(Scalar.new(33.9)) + ]; + // When training, it's important to shuffle your data! + const shuffledInputProviderBuilder = + new InCPUMemoryShuffledInputProviderBuilder([xs, ys]); + const [xProvider, yProvider] = + shuffledInputProviderBuilder.getInputProviders(); + + // Training is broken up into batches. + const NUM_BATCHES = 5; + const BATCH_SIZE = xs.length; + // Before we start training, we need to provide an optimizer. This is the + // object that is responsible for updating weights. The learning rate param + // is a value that represents how large of a step to make when updating + // weights. If this is too big, you may overstep and oscillate. If it is too + // small, the model may take a long time to train. + const LEARNING_RATE = .001; + const optimizer = new SGDOptimizer(LEARNING_RATE); + for (let i = 0; i < NUM_BATCHES; i++) { + // Train takes a cost tensor to minimize; this call trains one batch and + // returns the average cost of the batch as a Scalar. + const costValue = session.train( + cost, + // Map input providers to Tensors on the graph. + [{tensor: x, data: xProvider}, {tensor: y, data: yProvider}], + BATCH_SIZE, optimizer, CostReduction.MEAN); + + console.log('average cost: ' + costValue.get()); + } +}); +``` + +After the training the model, you can infer through the graph again to get a +value for "y" given an "x". + +Of course, in practice, you will not want to just use `Scalar` values. +**deeplearn.js** provides powerful hardware-accelerated linear algebra which +you can use for everything for image recognition, to text generation. See other +[tutorials](index.md) for more! diff --git a/karma.conf.js b/karma.conf.js new file mode 100644 index 0000000000..e1c29056b2 --- /dev/null +++ b/karma.conf.js @@ -0,0 +1,31 @@ +// Copyright 2017 Google Inc. 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. +// ============================================================================= + +module.exports = function(config) { + config.set({ + frameworks: ['jasmine', 'karma-typescript'], + files: [ + {pattern: 'src/**/*.ts'} + ], + preprocessors: { + '**/*.ts': ['karma-typescript'], // *.tsx for React Jsx + }, + karmaTypescriptConfig: { + tsconfig: "tsconfig.json" + }, + reporters: ['progress', 'karma-typescript'], + browsers: ['Chrome'] + }); +}; diff --git a/package.json b/package.json new file mode 100644 index 0000000000..c8410b6be7 --- /dev/null +++ b/package.json @@ -0,0 +1,35 @@ +{ + "name": "deeplearn", + "version": "0.1.0", + "description": "Hardware-accelerated JavaScript library for machine intelligence", + "private": false, + "main": "dist/src/index.js", + "types": "dist/src/index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/PAIR-code/deeplearnjs.git" + }, + "devDependencies": { + "@types/jasmine": "~2.5.53", + "@types/polymer": "~1.1.31", + "bower": "~1.8.0", + "browserify": "~14.4.0", + "http-server": "~0.10.0", + "jasmine-core": "~2.6.4", + "karma": "~1.7.0", + "karma-chrome-launcher": "~2.2.0", + "karma-jasmine": "~1.1.0", + "karma-typescript": "~3.0.4", + "polymer-bundler": "~3.0.1", + "tsify": "~3.0.1", + "tslint": "~5.5.0", + "typedoc": "~0.7.2", + "typescript": "2.3.4", + "watchify": "~3.9.0" + }, + "scripts": { + "prep": "npm install && bower install && mkdirp dist", + "test": "karma start", + "lint": "tslint -p . --type-check -t verbose" + } +} diff --git a/scripts/build-demo b/scripts/build-demo new file mode 100755 index 0000000000..6a8354eede --- /dev/null +++ b/scripts/build-demo @@ -0,0 +1,28 @@ +#!/usr/bin/env node +// Copyright 2017 Google Inc. 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. +// ============================================================================= + +const path = require('path'); +const spawn = require('child_process').spawn; + +const startTsFilePath = process.argv[2]; +const outputPath = path.join(path.dirname(startTsFilePath), 'bundle.js') + +const cmd = `node_modules/.bin/browserify`; +const child = spawn(cmd, [startTsFilePath, '-p', '[tsify]', '-o' , outputPath], + {detached: false}); +child.stdout.pipe(process.stdout); +child.stderr.pipe(process.stderr); +child.on('close', () => console.log(`Stored bundle in ${outputPath}`)); diff --git a/scripts/build-npm.sh b/scripts/build-npm.sh new file mode 100755 index 0000000000..e38b6e856d --- /dev/null +++ b/scripts/build-npm.sh @@ -0,0 +1,20 @@ +#!/usr/bin/env bash +# Copyright 2017 Google Inc. 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. +# ============================================================================= +node_modules/.bin/tsc +cd dist/ +npm pack ../ +cd .. +echo 'Stored npm package at dist/deeplearn-version.tgz' diff --git a/scripts/build-standalone.sh b/scripts/build-standalone.sh new file mode 100755 index 0000000000..a8b483603a --- /dev/null +++ b/scripts/build-standalone.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +# Copyright 2017 Google Inc. 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. +# ============================================================================= +mkdir -p dist/ +node_modules/.bin/browserify --standalone deeplearn src/index.ts -p [tsify] > dist/deeplearn.js +echo 'Stored standalone library at dist/deeplearn.js' diff --git a/scripts/convert_uint8_tensor_to_png.py b/scripts/convert_uint8_tensor_to_png.py new file mode 100644 index 0000000000..8fcdcb9f62 --- /dev/null +++ b/scripts/convert_uint8_tensor_to_png.py @@ -0,0 +1,63 @@ +# Copyright 2017 Google Inc. 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. +# ============================================================================== +"""Converts an array of 3D tensors to pngs.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import argparse +import os +import numpy as np +from PIL import Image + +FLAGS = None + + +def main(): + fpath = os.path.expanduser(FLAGS.uint8_tensor_file) + with open(fpath, 'rb') as f: + # a has shape N x Width x Height x Channels + a = np.frombuffer(f.read(), np.uint8).reshape( + [-1, FLAGS.size, FLAGS.size, FLAGS.num_channels]) + + print('Read', a.shape[0], 'images') + print('min/max pixel values: ', a.min(), '/', a.max()) + + # Make each image take a single row in the big batch image by flattening the + # width (2nd) and height (3rd) dimension. + # a has shape N x (Width*Height) x Channels. + a = a.reshape([a.shape[0], -1, FLAGS.num_channels]).squeeze() + im = Image.fromarray(a) + im.save(fpath + '.png') + print('Saved image with width/height', im.size, 'at', fpath + '.png') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument( + '--uint8_tensor_file', + type=str, + required=True, + help='File path to the binary uint8 tensor to convert to png') + parser.add_argument( + '--size', type=int, required=True, help='Width/Height of each image') + parser.add_argument( + '--num_channels', type=int, required=True, help='Number of channelse') + FLAGS, unparsed = parser.parse_known_args() + if unparsed: + print('Error, unrecognized flags:', unparsed) + exit(-1) + main() diff --git a/scripts/deploy-demo b/scripts/deploy-demo new file mode 100755 index 0000000000..7975a2cbbe --- /dev/null +++ b/scripts/deploy-demo @@ -0,0 +1,36 @@ +#!/usr/bin/env node +// Copyright 2017 Google Inc. 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. +// ============================================================================= + +const path = require('path'); +const spawn = require('child_process').spawn; + +const startTsFilePath = process.argv[2]; +const startHTMLFilePath = process.argv[3]; +const outDir = process.argv[4]; + +const cmd = `scripts/build-demo`; +const child = spawn(cmd, [startTsFilePath], {detached: false}); +child.stdout.pipe(process.stdout); +child.stderr.pipe(process.stderr); +child.on('close', () => { + const bundlePath = path.join(outDir, path.basename(startHTMLFilePath)); + const cmd = `node_modules/.bin/polymer-bundler`; + const child = spawn(cmd, ['--inline-scripts', '--inline-css', + '--out-html', bundlePath, startHTMLFilePath], {detached: false}); + child.stdout.pipe(process.stdout); + child.stderr.pipe(process.stderr); + child.on('close', () => console.log(`Saved bundled demo at ${bundlePath}`)); +}); diff --git a/scripts/dump_checkpoint_vars.py b/scripts/dump_checkpoint_vars.py new file mode 100644 index 0000000000..9255892b5c --- /dev/null +++ b/scripts/dump_checkpoint_vars.py @@ -0,0 +1,100 @@ +# Copyright 2017 Google Inc. 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. +# ============================================================================== +"""A script to dump tensorflow checkpoint variables to deeplearnjs. + +This script takes a checkpoint file and writes all of the variables in the +checkpoint to a directory. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import argparse +import json +import os +import re +import string +import tensorflow as tf + +FLAGS = None +FILENAME_CHARS = string.ascii_letters + string.digits + '_' + + +def _var_name_to_filename(var_name): + chars = [] + for c in var_name: + if c in FILENAME_CHARS: + chars.append(c) + elif c == '/': + chars.append('_') + return ''.join(chars) + + +def main(): + chk_fpath = os.path.expanduser(FLAGS.checkpoint_file) + reader = tf.train.NewCheckpointReader(chk_fpath) + var_to_shape_map = reader.get_variable_to_shape_map() + output_dir = os.path.expanduser(FLAGS.output_dir) + if not os.path.exists(output_dir): + os.mkdirs(output_dir) + manifest = {} + remove_vars_compiled_re = re.compile(FLAGS.remove_variables_regex) + + var_filenames_strs = [] + for name in var_to_shape_map: + if (FLAGS.remove_variables_regex and + re.match(remove_vars_compiled_re, name)) or name == 'global_step': + print('Ignoring ' + name) + continue + var_filename = _var_name_to_filename(name) + manifest[name] = {'filename': var_filename, 'shape': var_to_shape_map[name]} + + print('Writing variable ' + name + '...') + tensor = reader.get_tensor(name) + with open(os.path.join(output_dir, var_filename), 'w') as f: + f.write(tensor.tobytes()) + + var_filenames_strs.append("\"" + var_filename + "\"") + + manifest_fpath = os.path.join(output_dir, 'manifest.json') + print('Writing manifest to ' + manifest_fpath) + with open(manifest_fpath, 'w') as f: + f.write(json.dumps(manifest, indent=2, sort_keys=True)) + print('Done!') + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument( + '--checkpoint_file', + type=str, + required=True, + help='Path to the model checkpoint') + parser.add_argument( + '--output_dir', + type=str, + required=True, + help='The output directory where to store the converted weights') + parser.add_argument( + '--remove_variables_regex', + type=str, + default='', + help='A regular expression to match against variable names that should ' + 'not be included') + FLAGS, unparsed = parser.parse_known_args() + if unparsed: + print('Error, unrecognized flags:', unparsed) + exit(-1) + main() diff --git a/scripts/make-website.sh b/scripts/make-website.sh new file mode 100755 index 0000000000..f00bd24617 --- /dev/null +++ b/scripts/make-website.sh @@ -0,0 +1,53 @@ +#!/usr/bin/env bash +# Copyright 2017 Google Inc. 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. +# ============================================================================= +TMP_DIR="/tmp/deeplearn-website" + +npm run prep +rm -rf "$TMP_DIR" +mkdir "$TMP_DIR" + +cp -r "docs" "$TMP_DIR/" +cp "README.md" "$TMP_DIR/" + +# Make the documentation. +./node_modules/.bin/typedoc --out "$TMP_DIR/docs/api/" --excludeExternals \ + --excludeNotExported --excludePrivate --mode file --tsconfig tsconfig-doc.json + +# Build the demos (deploy-demo vulcanizes polymer apps). +cp -r "demos" "$TMP_DIR/" +./scripts/deploy-demo demos/model-builder/model-builder.ts \ + demos/model-builder/model-builder-demo.html $TMP_DIR/demos/model-builder/ +./scripts/deploy-demo demos/imagenet/imagenet-demo.ts \ + demos/imagenet/imagenet-demo.html $TMP_DIR/demos/imagenet +./scripts/deploy-demo demos/nn-art/nn-art.ts \ + demos/nn-art/nn-art-demo.html $TMP_DIR/demos/nn-art +./scripts/deploy-demo demos/benchmarks/math-benchmark.ts \ + demos/benchmarks/benchmark-demo.html $TMP_DIR/demos/benchmarks + +# Build the homepage (no deploy since homepage is not polymer). +./scripts/build-demo demos/homepage/index.ts +cp -r demos/homepage/* "$TMP_DIR" + +git stash +git checkout gh-pages + +cp -rf "$TMP_DIR"/* . + +git add . +git commit -m "github pages" + +git checkout master +git stash pop diff --git a/scripts/watch-demo b/scripts/watch-demo new file mode 100755 index 0000000000..c805e46cc2 --- /dev/null +++ b/scripts/watch-demo @@ -0,0 +1,33 @@ +#!/usr/bin/env node +// Copyright 2017 Google Inc. 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. +// ============================================================================= + +const path = require('path'); +const spawn = require('child_process').spawn; + +const startTsFilePath = process.argv[2]; +const outputPath = path.join(path.dirname(startTsFilePath), 'bundle.js') + +const cmd = `node_modules/.bin/watchify`; +const watchify = spawn(cmd, [startTsFilePath, '-p', '[tsify]', '-v', '--debug', + '-o' , outputPath], {detached: false}); +watchify.stdout.pipe(process.stdout); +watchify.stderr.pipe(process.stderr); + +const httpServer = spawn('node_modules/.bin/http-server', ['-c-1'], { + detached: false +}); +httpServer.stdout.pipe(process.stdout); +httpServer.stderr.pipe(process.stderr); diff --git a/src/checkpoint_loader.ts b/src/checkpoint_loader.ts new file mode 100644 index 0000000000..77e215255a --- /dev/null +++ b/src/checkpoint_loader.ts @@ -0,0 +1,137 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArray} from './math/ndarray'; + +/** + * @hidden + */ +export interface CheckpointVariable { + filename: string; + shape: number[]; +} + +/** + * @hidden + */ +export type CheckpointManifest = { + [varName: string]: CheckpointVariable +}; + +const MANIFEST_FILE = 'manifest.json'; + +export class CheckpointLoader { + private checkpointManifest: CheckpointManifest; + private variables: {[varName: string]: NDArray}; + + constructor(private urlPath: string) { + if (this.urlPath.charAt(this.urlPath.length - 1) !== '/') { + this.urlPath += '/'; + } + } + + private loadManifest(): Promise { + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); + xhr.open('GET', this.urlPath + MANIFEST_FILE); + + xhr.onload = () => { + this.checkpointManifest = JSON.parse(xhr.responseText); + resolve(); + }; + xhr.onerror = (error) => { + throw new Error( + `${MANIFEST_FILE} not found at ${this.urlPath}. ` + error); + }; + xhr.send(); + }); + } + + getCheckpointManifest(): Promise { + if (this.checkpointManifest == null) { + return new Promise((resolve, reject) => { + this.loadManifest().then(() => { + resolve(this.checkpointManifest); + }); + }); + } + return new Promise((resolve, reject) => { + resolve(this.checkpointManifest); + }); + } + + getAllVariables(): Promise<{[varName: string]: NDArray}> { + if (this.variables != null) { + return new Promise<{[varName: string]: NDArray}>((resolve, reject) => { + resolve(this.variables); + }); + } + + return new Promise<{[varName: string]: NDArray}>((resolve, reject) => { + this.getCheckpointManifest().then( + (checkpointDefinition: CheckpointManifest) => { + const variableNames = Object.keys(this.checkpointManifest); + + const variablePromises: Array> = []; + for (let i = 0; i < variableNames.length; i++) { + variablePromises.push(this.getVariable(variableNames[i])); + } + + Promise.all(variablePromises).then(variables => { + this.variables = {}; + for (let i = 0; i < variables.length; i++) { + this.variables[variableNames[i]] = variables[i]; + } + resolve(this.variables); + }); + }); + }); + } + + getVariable(varName: string): Promise { + if (!(varName in this.checkpointManifest)) { + throw new Error('Cannot load non-existant variable ' + varName); + } + + const variableRequestPromiseMethod = + (resolve: (ndarray: NDArray) => void, reject: () => void) => { + const xhr = new XMLHttpRequest(); + xhr.responseType = 'arraybuffer'; + const fname = this.checkpointManifest[varName].filename; + xhr.open('GET', this.urlPath + fname); + + xhr.onload = () => { + const values = new Float32Array(xhr.response); + const ndarray = + NDArray.make(this.checkpointManifest[varName].shape, {values}); + resolve(ndarray); + }; + xhr.onerror = (error) => { + throw new Error( + 'Could not fetch variable ' + varName + ': ' + error); + }; + xhr.send(); + }; + + if (this.checkpointManifest == null) { + return new Promise((resolve, reject) => { + this.loadManifest().then(() => { + new Promise(variableRequestPromiseMethod).then(resolve); + }); + }); + } + return new Promise(variableRequestPromiseMethod); + } +} diff --git a/src/checkpoint_loader_test.ts b/src/checkpoint_loader_test.ts new file mode 100644 index 0000000000..852f3e8c9b --- /dev/null +++ b/src/checkpoint_loader_test.ts @@ -0,0 +1,99 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {CheckpointLoader, CheckpointManifest} from './checkpoint_loader'; + +describe('Checkpoint var loader', () => { + let xhrObj: XMLHttpRequest; + + beforeEach(() => { + xhrObj = jasmine.createSpyObj( + 'xhrObj', ['addEventListener', 'open', 'send', 'onload', 'onerror']); + // tslint:disable-next-line:no-any + spyOn(window as any, 'XMLHttpRequest').and.returnValue(xhrObj); + }); + + it('Load manifest and a variable', (doneFn) => { + const fakeCheckpointManifest: CheckpointManifest = { + 'fakeVar1': {filename: 'fakeFile1', shape: [10]}, + 'fakeVar2': {filename: 'fakeFile2', shape: [5, 5]} + }; + + const varLoader = new CheckpointLoader('fakeModel'); + varLoader.getCheckpointManifest().then(checkpoint => { + expect(checkpoint).toEqual(fakeCheckpointManifest); + + const buffer = + new ArrayBuffer(4 * fakeCheckpointManifest['fakeVar1'].shape[0]); + const view = new Float32Array(buffer); + for (let i = 0; i < 10; i++) { + view[i] = i; + } + + varLoader.getVariable('fakeVar1').then(ndarray => { + expect(ndarray.shape).toEqual(fakeCheckpointManifest['fakeVar1'].shape); + expect(ndarray.getValues()).toEqual(view); + doneFn(); + }); + // tslint:disable-next-line:no-any + (xhrObj as any).response = buffer; + // tslint:disable-next-line:no-any + (xhrObj as any).onload(); + }); + // tslint:disable-next-line:no-any + (xhrObj as any).responseText = JSON.stringify(fakeCheckpointManifest); + // tslint:disable-next-line:no-any + (xhrObj as any).onload(); + }); + + it('Load manifest error', () => { + const varLoader = new CheckpointLoader('fakeModel'); + varLoader.getCheckpointManifest(); + // tslint:disable-next-line:no-any + expect(() => (xhrObj as any).onerror()).toThrowError(); + }); + + it('Load non-existent variable throws error', (doneFn) => { + const fakeCheckpointManifest: + CheckpointManifest = {'fakeVar1': {filename: 'fakeFile1', shape: [10]}}; + + const varLoader = new CheckpointLoader('fakeModel'); + varLoader.getCheckpointManifest().then(checkpoint => { + expect(() => varLoader.getVariable('varDoesntExist')).toThrowError(); + doneFn(); + }); + // tslint:disable-next-line:no-any + (xhrObj as any).responseText = JSON.stringify(fakeCheckpointManifest); + // tslint:disable-next-line:no-any + (xhrObj as any).onload(); + }); + + it('Load variable throws error', (doneFn) => { + const fakeCheckpointManifest: + CheckpointManifest = {'fakeVar1': {filename: 'fakeFile1', shape: [10]}}; + + const varLoader = new CheckpointLoader('fakeModel'); + varLoader.getCheckpointManifest().then(checkpoint => { + varLoader.getVariable('fakeVar1'); + // tslint:disable-next-line:no-any + expect(() => (xhrObj as any).onerror()).toThrowError(); + doneFn(); + }); + // tslint:disable-next-line:no-any + (xhrObj as any).responseText = JSON.stringify(fakeCheckpointManifest); + // tslint:disable-next-line:no-any + (xhrObj as any).onload(); + }); +}); diff --git a/src/dataset.ts b/src/dataset.ts new file mode 100644 index 0000000000..c1d4762907 --- /dev/null +++ b/src/dataset.ts @@ -0,0 +1,266 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMath} from './math/math'; +import {NDArray} from './math/ndarray'; +import * as util from './util'; + +const STATS_SAMPLE_PERCENTAGE = 0.1; + +export interface DataStats { + exampleCount: number; + inputMin: number; + inputMax: number; + shape: number[]; +} + +interface NormalizationInfo { + isNormalized: boolean; + // Bounds of the normalization if normalized. + lowerBound?: number; + upperBound?: number; + // Minimum and maximum values for each dimension of the original data. These + // are the same size as an input example. These are computed lazily, only if + // normalization is requested. If the data is un-normalized, these are kept + // around so they don't have to be recomputed. + minValues: Float32Array; + maxValues: Float32Array; +} + +export abstract class InMemoryDataset { + protected dataset: NDArray[][]|null; + + // Contains information necessary for reconstruction of the original data + // after normalization. + private normalizationInfo: {[dataIndex: number]: NormalizationInfo}; + + constructor(protected dataShapes: number[][]) { + this.normalizationInfo = {}; + } + + getDataShape(dataIndex: number): number[] { + return this.dataShapes[dataIndex]; + } + + abstract fetchData(): Promise; + + getData(): NDArray[][]|null { + return this.dataset; + } + + getStats(): DataStats[] { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + + return this.dataset.map(d => this.getStatsForData(d)); + } + + // Computes stats across a sampled portion of the data. + private getStatsForData(data: NDArray[]): DataStats { + let inputMin = Number.POSITIVE_INFINITY; + let inputMax = Number.NEGATIVE_INFINITY; + + let exampleIndices = data.map((example, i) => i); + util.shuffle(exampleIndices); + exampleIndices = + exampleIndices.slice(exampleIndices.length * STATS_SAMPLE_PERCENTAGE); + + for (let i = 0; i < exampleIndices.length; i++) { + const inputValues = data[exampleIndices[i]].getValues(); + for (let j = 0; j < inputValues.length; j++) { + inputMin = Math.min(inputMin, inputValues[j]); + inputMax = Math.max(inputMax, inputValues[j]); + } + } + + return { + inputMin, + inputMax, + exampleCount: data.length, + shape: data[0].shape, + }; + } + + /** + * @param examples NDArrays to be normalized. + * @param curLowerBounds An array containing the minimum value for each + * dimension or a fixed minimum value. + * @param curUpperBounds An array containing the maximum value for each + * dimension or a fixed maximum value. + * @param newLowerBounds An array containing new minimum values for each + * dimension, or a fixed minumum value to normalize the data to. + * @param newUpperBounds An array containing new maximum values for each + * dimension, or a fixed maximum value to normalize the data to. + */ + private normalizeExamplesToRange( + examples: NDArray[], curLowerBounds: Float32Array|number, + curUpperBounds: Float32Array|number, newLowerBounds: Float32Array|number, + newUpperBounds: Float32Array|number): NDArray[] { + const curBoundsIsPerDimension = + (curUpperBounds instanceof Float32Array && + curLowerBounds instanceof Float32Array); + const newBoundsIsPerDimension = + (newLowerBounds instanceof Float32Array && + newUpperBounds instanceof Float32Array); + + const inputSize = util.sizeFromShape(examples[0].shape); + const newExamples: NDArray[] = []; + + examples.forEach(example => { + const inputValues = example.getValues(); + const normalizedValues = new Float32Array(inputSize); + for (let j = 0; j < inputSize; j++) { + const curLowerBound = curBoundsIsPerDimension ? + (curLowerBounds as Float32Array)[j] : + curLowerBounds as number; + const curUpperBound = curBoundsIsPerDimension ? + (curUpperBounds as Float32Array)[j] : + curUpperBounds as number; + const curRange = curUpperBound - curLowerBound; + + const newLowerBound = newBoundsIsPerDimension ? + (newLowerBounds as Float32Array)[j] : + newLowerBounds as number; + const newUpperBound = newBoundsIsPerDimension ? + (newUpperBounds as Float32Array)[j] : + newUpperBounds as number; + const newRange = newUpperBound - newLowerBound; + + if (curRange === 0) { + normalizedValues[j] = newLowerBound; + } else { + normalizedValues[j] = newLowerBound + + newRange * (inputValues[j] - curLowerBound) / curRange; + } + } + newExamples.push(NDArray.make(example.shape, {values: normalizedValues})); + }); + return newExamples; + } + + private computeBounds(dataIndex: number) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + + const size = util.sizeFromShape(this.dataset[dataIndex][0].shape); + + // Compute min and max values for every dimension. + this.normalizationInfo[dataIndex] = { + isNormalized: false, + minValues: new Float32Array(size), + maxValues: new Float32Array(size) + }; + + for (let i = 0; i < size; i++) { + this.normalizationInfo[dataIndex].minValues[i] = Number.POSITIVE_INFINITY; + this.normalizationInfo[dataIndex].maxValues[i] = Number.NEGATIVE_INFINITY; + } + + this.dataset[dataIndex].forEach(example => { + const inputValues = example.getValues(); + for (let k = 0; k < size; k++) { + this.normalizationInfo[dataIndex].minValues[k] = Math.min( + this.normalizationInfo[dataIndex].minValues[k], inputValues[k]); + this.normalizationInfo[dataIndex].maxValues[k] = Math.max( + this.normalizationInfo[dataIndex].maxValues[k], inputValues[k]); + } + }); + } + + normalizeWithinBounds( + dataIndex: number, lowerBound: number, upperBound: number) { + if (this.dataset == null) { + throw new Error('Data is null.'); + } + if (dataIndex >= this.dataset.length) { + throw new Error('dataIndex out of bounds.'); + } + + if (this.normalizationInfo[dataIndex] == null) { + this.computeBounds(dataIndex); + } + + // curLower/UpperBounds of the current data set can either be fixed numbers + // if the data has already been normalized, or curLower/Upper for each + // dimension if it hasn't been normalized yet. + let curLowerBounds: Float32Array|number; + let curUpperBounds: Float32Array|number; + + if (this.normalizationInfo[dataIndex].isNormalized) { + curLowerBounds = this.normalizationInfo[dataIndex].lowerBound!; + curUpperBounds = this.normalizationInfo[dataIndex].upperBound!; + } else { + curLowerBounds = this.normalizationInfo[dataIndex].minValues; + curUpperBounds = this.normalizationInfo[dataIndex].maxValues; + } + + this.dataset[dataIndex] = this.normalizeExamplesToRange( + this.dataset[dataIndex], curLowerBounds, curUpperBounds, lowerBound, + upperBound); + this.normalizationInfo[dataIndex].isNormalized = true; + this.normalizationInfo[dataIndex].lowerBound = lowerBound; + this.normalizationInfo[dataIndex].upperBound = upperBound; + } + + private isNormalized(dataIndex: number): boolean { + return this.normalizationInfo != null && + this.normalizationInfo[dataIndex].isNormalized; + } + + removeNormalization(dataIndex: number) { + if (this.dataset == null) { + throw new Error('Training or test data is null.'); + } + + if (!this.isNormalized(dataIndex)) { + return; + } + + this.dataset[dataIndex] = this.normalizeExamplesToRange( + this.dataset[dataIndex], this.normalizationInfo[dataIndex].lowerBound!, + this.normalizationInfo[dataIndex].upperBound!, + this.normalizationInfo[dataIndex].minValues, + this.normalizationInfo[dataIndex].maxValues); + this.normalizationInfo[dataIndex].isNormalized = false; + } + + unnormalizeExamples(examples: NDArray[], dataIndex: number): NDArray[] { + if (!this.isNormalized(dataIndex)) { + return examples; + } + + return this.normalizeExamplesToRange( + examples, this.normalizationInfo[dataIndex].lowerBound!, + this.normalizationInfo[dataIndex].upperBound!, + this.normalizationInfo[dataIndex].minValues, + this.normalizationInfo[dataIndex].maxValues); + } + + dispose() { + if (this.dataset == null) { + return; + } + + for (let i = 0; i < this.dataset.length; i++) { + for (let j = 0; j < this.dataset[i].length; j++) { + this.dataset[i][j].dispose(); + } + } + this.dataset = []; + } +} + diff --git a/src/dataset_test.ts b/src/dataset_test.ts new file mode 100644 index 0000000000..669db46fd2 --- /dev/null +++ b/src/dataset_test.ts @@ -0,0 +1,100 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {InMemoryDataset} from './dataset'; +import {Array1D, Array2D, NDArray} from './math/ndarray'; +import * as test_util from './test_util'; + +class StubDataset extends InMemoryDataset { + constructor(data: NDArray[][]) { + super(data.map(value => value[0].shape)); + this.dataset = data; + } + + fetchData(): Promise { + return new Promise((resolve, reject) => {}); + } +} + +describe('Dataset', () => { + it('normalize', () => { + const data = [ + [ + Array2D.new([2, 3], new Float32Array([1, 2, 10, -1, -2, .75])), + Array2D.new([2, 3], new Float32Array([2, 3, 20, -2, 2, .5])), + Array2D.new([2, 3], new Float32Array([3, 4, 30, -3, -4, 0])), + Array2D.new([2, 3], new Float32Array([4, 5, 40, -4, 4, 1])) + ], + [ + Array1D.randNormal([1]), Array1D.randNormal([1]), + Array1D.randNormal([1]), Array1D.randNormal([1]) + ] + ]; + const dataset = new StubDataset(data); + + // Normalize only the first data index. + const dataIndex = 0; + dataset.normalizeWithinBounds(dataIndex, 0, 1); + + let normalizedInputs = dataset.getData()![0]; + + test_util.expectArraysClose( + new Float32Array([0, 0, 0, 1, .25, .75]), + normalizedInputs[0].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([1 / 3, 1 / 3, 1 / 3, 2 / 3, .75, .5]), + normalizedInputs[1].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([2 / 3, 2 / 3, 2 / 3, 1 / 3, 0, 0]), + normalizedInputs[2].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([1, 1, 1, 0, 1, 1]), normalizedInputs[3].getValues(), + 1e-5); + + dataset.normalizeWithinBounds(dataIndex, -1, 1); + + normalizedInputs = dataset.getData()![0]; + + test_util.expectArraysClose( + new Float32Array([-1, -1, -1, 1, -.5, .5]), + normalizedInputs[0].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([-1 / 3, -1 / 3, -1 / 3, 1 / 3, .5, .0]), + normalizedInputs[1].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([1 / 3, 1 / 3, 1 / 3, -1 / 3, -1, -1]), + normalizedInputs[2].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([1, 1, 1, -1, 1, 1]), normalizedInputs[3].getValues(), + 1e-5); + + dataset.removeNormalization(dataIndex); + + normalizedInputs = dataset.getData()![0]; + + test_util.expectArraysClose( + new Float32Array([1, 2, 10, -1, -2, .75]), + normalizedInputs[0].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([2, 3, 20, -2, 2, .5]), + normalizedInputs[1].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([3, 4, 30, -3, -4, 0]), + normalizedInputs[2].getValues(), 1e-5); + test_util.expectArraysClose( + new Float32Array([4, 5, 40, -4, 4, 1]), normalizedInputs[3].getValues(), + 1e-5); + }); +}); diff --git a/src/graph.ts b/src/graph.ts new file mode 100644 index 0000000000..900f170298 --- /dev/null +++ b/src/graph.ts @@ -0,0 +1,905 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GraphLayers} from './graph_layers'; +import * as concat3d_util from './math/concat3d_util'; +import * as conv_util from './math/conv_util'; +import {NDArray, Scalar} from './math/ndarray'; +import * as util from './util'; + +/** + * Graph is the primary container structure for deeplearn.js operations. Graph + * holds the topology of operation nodes and the connectivity between them. + */ +export class Graph { + layers: GraphLayers; + + constructor() { + this.layers = new GraphLayers(this); + } + + /** + * Creates a named variable. Variables are tensors that maintain state across + * session calls and whose values are adjusted during backpropagation + * training. + * @param name The name of this variable. + * @param data The NDArray to associate with this variable tensor. + * @return The tensor representing the variable. + */ + variable(name: string, data: NDArray): Tensor { + return this.addNodeAndReturnOutput(new VariableNode(this, name, data)); + } + + /** + * Inserts a placeholder for a tensor that will be always fed. Placeholders + * are input tensors whose values are provided by the client via feed + * dictionaries. Placeholders are not updated as part of training; they are + * only used as immutable input. + * @param name The name of this placeholder. + * @param shape The shape of the placeholder tensor. + * @return The tensor representing the placeholder. + */ + placeholder(name: string, shape: number[]): Tensor { + return this.addNodeAndReturnOutput(new PlaceholderNode(this, name, shape)); + } + + /** + * Constant value that persists across session calls. + * @param value The value to return. + * @return A node outputing the constant value. + */ + constant(value: ArrayData): Tensor { + let finalValue: NDArray; + if (typeof value === 'number') { + finalValue = Scalar.new(value); + } else if (value instanceof NDArray) { + finalValue = value; + } else if (value instanceof Array) { + const vals = new Float32Array(util.flatten(value)); + finalValue = NDArray.make(util.inferShape(value), {values: vals}); + } else { + throw new Error('unimplemented constant type.'); + } + return this.addNodeAndReturnOutput(new ConstantNode(this, finalValue)); + } + + /** + * Reshape the input tensor. + * @param x The input tensor to be reshaped. + * @param shape The shape of the output tensor. + * @return The tensor representing the reshape operation. + */ + reshape(x: Tensor, shape: number[]): Tensor { + return this.addNodeAndReturnOutput( + new ReshapeNode(this, 'Reshape', x, shape)); + } + + /** + * Computes a fused linear combination of two tensors. + * @param x1 The first input tensor. + * @param x2 The second input tensor. Same shape as t1. + * @param c1 Coefficient of t1. Must be size 1. + * @param c2 Coefficient of t2. Must be size 1. + * @return The tensor representing c1*t1+c2*t2. + */ + fusedLinearCombination(x1: Tensor, x2: Tensor, c1: Tensor, c2: Tensor): + Tensor { + return this.addNodeAndReturnOutput( + new FusedLinearCombinationNode(this, x1, x2, c1, c2)); + } + + + /** + * Adds two tensors (elementwise). Broadcasts if one of the tensors is scalar. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing t1+t2. + */ + add(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new AddNode(this, x1, x2)); + } + + /** + * Subtracts two tensors (elementwise). Broadcasts if one of the tensors is + * scalar. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing t1-t2. + */ + subtract(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new SubtractNode(this, x1, x2)); + } + + /** + * Multiply two tensors (elementwise). Broadcasts if one of the tensors is + * scalar. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing t1*t2. + */ + multiply(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new MultiplyNode(this, x1, x2)); + } + + /** + * Divide two tensors (elementwise). Broadcasts if one of the tensors is + * scalar. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing t1 / t2. + */ + divide(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new DivideNode(this, x1, x2)); + } + + /** + * Computes the sum of elements in the tensor. + * @param x The input tensor. + */ + reduceSum(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new ReduceSumNode(this, x)); + } + + /** + * Concats two 3D tensors along a given axis. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing concat of two tensors along axis. + */ + concat3d(x1: Tensor, x2: Tensor, axis: number): Tensor { + return this.addNodeAndReturnOutput(new Concat3DNode(this, x1, x2, axis)); + } + + /** + * Computes the dot product between two matrices. + * @param x1 The first input tensor. + * @param x2 The second input tensor. + * @return The tensor representing the dot product of x1 and x2. + */ + matmul(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new MatMulNode(this, x1, x2)); + } + + /** + * Computes a 2D convolution. + * @param x The input tensor to the convolution operation. + * @param w The weight tensor used by the convolution operation. + * @param b The bias tensor used by the convolution operation. + * @param fieldSize The size of the convolutional kernel. + * @param outputDepth The output depth of the convolution operation. + * @param stride The stride of the convolution operation. + * @param zeroPad The amount of zero padding on all sides of the input tensor. + * @return The tensor representing the convolution operation. + */ + conv2d( + x: Tensor, w: Tensor, b: Tensor, fieldSize: number, outputDepth: number, + stride = 1, zeroPad?: number): Tensor { + return this.addNodeAndReturnOutput(new Convolution2DNode( + this, x, w, b, fieldSize, outputDepth, stride, zeroPad)); + } + + /** + * Computes a 2D max pool of x. + * @param x The input tensor to the max pool operation. + * @param fieldSize The size of the convolutional kernel. + * @param stride The stride of the convolution operation. + * @param zeroPad The amount of zero padding on all sides of the input tensor. + * @return The tensor representing the max pool operation. + */ + maxPool(x: Tensor, fieldSize: number, stride = 1, zeroPad?: number): Tensor { + return this.addNodeAndReturnOutput( + new MaxPoolNode(this, x, fieldSize, stride, zeroPad)); + } + + /** + * Computes exponential of x element-wise. + * @param x The input tensor to the exp. + * @return The tensor representing the e ^ x operation. + */ + exp(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new ExpNode(this, x)); + } + + /** + * Computes log of x element-wise. + * @param x The input tensor to the log. + * @return The tensor representing the ln(x) operation. + */ + log(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new LogNode(this, x)); + } + + /** + * Computes ReLU of x element-wise. + * @param x The input tensor to the ReLU. + * @return The tensor representing the ReLU operation. + */ + relu(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new ReLUNode(this, x)); + } + + /** + * Computes TanH of x element-wise. + * @param x The input tensor to the TanH. + * @return The tensor representing the TanH operation. + */ + tanh(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new TanHNode(this, x)); + } + + /** + * Computes Sigmoid of x element-wise. + * @param x The input tensor to the sigmoid. + * @return The tensor representing the sigmoid operation. + */ + sigmoid(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new SigmoidNode(this, x)); + } + + /** + * Computes square of x element-wise. + * @param x The input tensor to the square. + */ + square(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new SquareNode(this, x)); + } + + /** + * Computes softmax probabilities from logits. + * + * @param x The input logits. + * @return The softmax probabilities. + */ + softmax(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new SoftmaxNode(this, x)); + } + + /** + * Creates a softmax cross-entropy cost operation in the graph. + * @param x The input tensor to classify. + * @return The tensor representing the softmax cross-entropy cost operation. + */ + softmaxCrossEntropyCost(x: Tensor, target: Tensor): Tensor { + return this.addNodeAndReturnOutput( + new SoftmaxCrossEntropyCostNode(this, x, target)); + } + + /** + * Creates a mean-squared cost operation in the graph. + * @param label The label tensor. + * @param prediction The prediction tensor. + * @return The tensor representing the mean-squared cost operation. + */ + meanSquaredCost(label: Tensor, prediction: Tensor) { + return this.addNodeAndReturnOutput( + new MeanSquaredCostNode(this, label, prediction)); + } + + /** + * Returns the flattened index of the maximum entry in the tensor. + * @param x The tensor with the value. + * @return A Scalar tensor with the index of the maximum entry. + */ + argmax(x: Tensor): Tensor { + return this.addNodeAndReturnOutput(new ArgMaxNode(this, x)); + } + + /** + * Creates an argmax equals operation in the graph. + * @param x1 First input tensor to check against. + * @param x2 Second input tensor to check against. + * @return The tensor representing the argmax equals operation. + */ + argmaxEquals(x1: Tensor, x2: Tensor): Tensor { + return this.addNodeAndReturnOutput(new ArgMaxEqualsNode(this, x1, x2)); + } + + private addNodeAndReturnOutput(node: Node): Tensor { + this.nodes.push(node); + node.validate(); + return node.output; + } + + getNodes(): Node[] { + return this.nodes; + } + + private nodes: Node[] = []; +} + +/** + * Tensor represents the output of an operation node in the graph. + * Tensors have no data associated with them, but maintain a shape array + * to determine operation compatibility. All graph methods that create graph + * operations return Tensor objects, which can be thought of as 'handles' to + * operations. + */ +export class Tensor { + node: Node; + id: number; + /** + * @param shape The shape of this tensor, in dimension sizes. + */ + constructor(public shape: number[]) { + this.id = Tensor.nextID++; + } + private static nextID = 0; +} + +/** + * Node is the concrete base class for all operations in the graph. + * Users generally don't need to interact directly with Node instances, but they + * are provided for informational and introspection purposes. + * + * @hidden + */ +export abstract class Node { + /** + * @param graph The graph containing this node + * @param name The name of this node + * @param inputs A dictionary of named Tensors that comprise this node's + * inputs. + * @param output This node's output Tensor + */ + constructor( + public graph: Graph, public name: string, + public inputs: {[name: string]: Tensor}, public output: Tensor) { + this.id = Node.nextID++; + output.node = this; + } + abstract validate(): void; + id: number; + private static nextID = 0; +} + +/** + * VariableNode represents a variable, a user-provided NDArray that's + * adjusted during backpropagation training. + * + * @hidden + */ +export class VariableNode extends Node { + constructor(graph: Graph, name: string, public data: NDArray) { + super(graph, name, {}, new Tensor(data.shape)); + } + validate() { + util.assert( + this.data != null, + 'Error adding variable op: Data for variable \'' + this.name + + '\' is null or undefined'); + } +} + +/** + * PlaceholderNode represents a placeholder, a user-provided NDArray + * that's used as immutable input during inference and training. + * + * @hidden + */ +export class PlaceholderNode extends Node { + constructor(graph: Graph, name: string, shape: number[]) { + super(graph, name, {}, new Tensor(shape)); + } + validate() {} +} + +/** + * ConstantNode represents a constant value in the graph. + * + * @hidden + */ +export class ConstantNode extends Node { + constructor(graph: Graph, public data: NDArray) { + super(graph, 'Constant', {}, new Tensor(data.shape)); + } + validate() { + util.assert( + this.data != null, + 'Error adding constant: data for placeholder \'' + this.name + + '\' is null or undefined'); + } +} + +/** + * ReshapeNode represents a reshape operation in the graph. + * + * @hidden + */ +export class ReshapeNode extends Node { + static readonly X = 'x'; + constructor( + graph: Graph, public name: string, private x: Tensor, + private shape: number[]) { + super(graph, name, {x}, new Tensor(shape)); + } + validate() { + const xSize = util.sizeFromShape(this.x.shape); + const shapeSize = util.sizeFromShape(this.shape); + util.assert( + xSize === shapeSize, + 'Error making reshape operation: input Tensor to reshape \'' + + this.name + '\' of shape (' + this.x.shape + + ') does not match size of requested shape ' + this.shape + '.'); + } +} + +/** + * LinearCombinationNode represents a linear combination of two tensors. + * @hidden + */ +export class FusedLinearCombinationNode extends Node { + static readonly T1 = 't1'; + static readonly T2 = 't2'; + static readonly C1 = 'c1'; + static readonly C2 = 'c2'; + constructor( + graph: Graph, private t1: Tensor, private t2: Tensor, private c1: Tensor, + private c2: Tensor) { + super(graph, 'Linear Combination', {t1, t2, c1, c2}, new Tensor(t1.shape)); + } + + validate() { + util.assertShapesMatch(this.t1.shape, this.t2.shape); + if (!util.isScalarShape(this.c1.shape)) { + throw new Error( + 'Error adding fusedLinearCombination: c1 is not a scalar, got ' + + 'shape: ' + this.c1.shape); + } + if (!util.isScalarShape(this.c2.shape)) { + throw new Error( + 'Error adding fusedLinearCombination: c2 is not a scalar, got ' + + 'shape: ' + this.c2.shape); + } + } +} + +/** + * @hidden + */ +export class AddNode extends Node { + static readonly T1 = 't1'; + static readonly T2 = 't2'; + + constructor(graph: Graph, private t1: Tensor, private t2: Tensor) { + super( + graph, 'Add', {t1, t2}, + new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)); + } + + validate() { + util.assert( + util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), + 'Error adding add operation op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + } +} + +/** + * @hidden + */ +export class SubtractNode extends Node { + static readonly T1 = 't1'; + static readonly T2 = 't2'; + + constructor(graph: Graph, private t1: Tensor, private t2: Tensor) { + super( + graph, 'Subtract', {t1, t2}, + new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)); + } + + validate() { + util.assert( + util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), + 'Error adding subtract op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + } +} + +/** + * @hidden + */ +export class MultiplyNode extends Node { + static readonly T1 = 't1'; + static readonly T2 = 't2'; + + constructor(graph: Graph, private t1: Tensor, private t2: Tensor) { + super( + graph, 'Multiply', {t1, t2}, + new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)); + } + + validate() { + util.assert( + util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), + 'Error adding multiply op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + } +} + +/** + * @hidden + */ +export class DivideNode extends Node { + static readonly T1 = 't1'; + static readonly T2 = 't2'; + + constructor(graph: Graph, private t1: Tensor, private t2: Tensor) { + super( + graph, 'Divide', {t1, t2}, + new Tensor(util.sizeFromShape(t1.shape) === 1 ? t2.shape : t1.shape)); + } + + validate() { + util.assert( + util.sizeFromShape(this.t1.shape) === 1 || + util.sizeFromShape(this.t2.shape) === 1 || + util.arraysEqual(this.t1.shape, this.t2.shape), + 'Error adding divide op: one of inputs must be scalar or the ' + + 'shapes ' + this.t1.shape + ' and ' + this.t2.shape + + ' must match.'); + } +} + +/** + * @hidden + */ +export class ReduceSumNode extends Node { + static readonly X = 'x'; + + constructor(graph: Graph, x: Tensor) { + super(graph, 'ReduceSum', {x}, new Tensor([])); + } + + validate() {} +} + +/** + * Concat3DNode represents a 3D concatenation of two tensors along an axis. + * @hidden + */ +export class Concat3DNode extends Node { + static readonly X1 = 'x1'; + static readonly X2 = 'x2'; + static readonly AXIS = 'axis'; + constructor( + graph: Graph, private x1: Tensor, private x2: Tensor, + public axis: number) { + super( + graph, 'Concat3D', {x1, x2}, + new Tensor(concat3d_util.computeConcat3DOutputShape( + x1.shape, x2.shape, axis))); + } + validate() { + concat3d_util.assertConcat3DShapesMatch( + this.x1.shape, this.x2.shape, this.axis); + } +} + +function getMatMulOutputShape(x1Shape: number[], x2Shape: number[]): number[] { + if (x1Shape.length === 1 && x2Shape.length === 1) { + return [1]; + } else if (x1Shape.length === 1 && x2Shape.length === 2) { + return [x2Shape[1]]; + } else if (x1Shape.length === 2 && x2Shape.length === 1) { + return [x1Shape[0]]; + } + return [x1Shape[0], x2Shape[1]]; +} + +/** + * MatMulNode represents a fully connected layer in the graph. + * @hidden + */ +export class MatMulNode extends Node { + static readonly X1 = 'x1'; + static readonly X2 = 'x2'; + constructor(graph: Graph, private x1: Tensor, private x2: Tensor) { + super( + graph, 'MatMul', {x1, x2}, + new Tensor(getMatMulOutputShape(x1.shape, x2.shape))); + } + + validate() { + if (this.x1.shape.length === 2 && this.x2.shape.length === 2) { + util.assert( + this.x1.shape[1] === this.x2.shape[0], + 'Error adding matmul op: inner shapes of matrices with shapes ' + + this.x1.shape + ' and ' + this.x2.shape + ' must match.'); + } else if (this.x1.shape.length === 2 && this.x2.shape.length === 1) { + util.assert( + this.x1.shape[1] === this.x2.shape[0], + 'Error adding matmul op: second dimension of matrix with shape ' + + this.x1.shape + ' must match size of vector with shape ' + + this.x2.shape + '.'); + } else if (this.x1.shape.length === 1 && this.x2.shape.length === 2) { + util.assert( + this.x1.shape[0] === this.x2.shape[0], + 'Error adding matmul op: size of vector with shape ' + this.x1.shape + + ' must match first dimension of matrix with ' + + 'shape ' + this.x2.shape + '.'); + } else { + throw new Error( + 'Error adding matmul op: inputs must be vectors or matrices.'); + } + } +} + +/** + * Convolution2DNode represents a 2d convolution operation in the graph. + * @hidden + */ +export class Convolution2DNode extends Node { + static readonly X = 'x'; + static readonly W = 'w'; + static readonly B = 'b'; + constructor( + graph: Graph, private x: Tensor, private w: Tensor, private b: Tensor, + public fieldSize: number, public outputDepth: number, public stride = 1, + public zeroPad?: number) { + super( + graph, 'Convolution 2D', {x, w, b}, + new Tensor(conv_util.computeOutputShape3D( + x.shape as [number, number, number], fieldSize, outputDepth, stride, + zeroPad))); + } + validate() { + util.assert( + this.x.shape.length === 3, + 'Error adding conv2d op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + util.assert( + this.w.shape.length === 4, + 'Error adding conv2d op: weights must be of rank 4, but got shape: ' + + this.w.shape + '.'); + util.assert( + this.b.shape.length === 1, + 'Error adding conv2d op: biases must be of rank 1, but got shape: ' + + this.b.shape + '.'); + + util.assert( + this.x.shape[2] === this.w.shape[2], + 'Error adding conv2d op: depth of input (' + this.x.shape[2] + + ') must match input depth for weights (' + this.w.shape[2] + ').'); + } +} + +/** + * MaxPoolNode represents a 2d max pool operation in the graph. + * @hidden + */ +export class MaxPoolNode extends Node { + static readonly X = 'x'; + constructor( + graph: Graph, private x: Tensor, public fieldSize: number, + public stride = 1, public zeroPad?: number) { + super( + graph, 'Max pool', {x}, + new Tensor(conv_util.computeOutputShape3D( + x.shape as [number, number, number], fieldSize, x.shape[2], stride, + zeroPad))); + } + validate() { + util.assert( + this.x.shape.length === 3, + 'Error adding maxPool op: input must be of rank 3, but got shape: ' + + this.x.shape + '.'); + } +} + +/** + * ReLUNode represents a ReLU operation in the graph. + * @hidden + */ +export class ReLUNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'ReLU', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * ExpNode represents a Exponentiation operation in the graph. + * @hidden + */ +export class ExpNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'Exp', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * LogNode represents a Exponentiation operation in the graph. + * @hidden + */ +export class LogNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'Log', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * TanHNode represents a tanh operation in the graph. + * @hidden + */ +export class TanHNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'TanH', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * SigmoidNode represents a sigmoid operation in the graph. + * @hidden + */ +export class SigmoidNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'Sigmoid', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * Square node represents an element-wise square operation in the graph. + * @hidden + */ +export class SquareNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, x: Tensor) { + super(graph, 'Square', {x}, new Tensor(x.shape)); + } + validate() {} +} + +/** + * SoftmaxCrossEntropyCostNode represents a softmax cross-entropy cost operation + * in the graph. + * @hidden + */ +export class SoftmaxCrossEntropyCostNode extends Node { + static readonly X = 'x'; + static readonly TARGET = 'target'; + constructor(graph: Graph, private x: Tensor, private target: Tensor) { + super(graph, 'SoftmaxCrossEntropyCost', {x, target}, new Tensor([])); + } + validate() { + util.assert( + util.arraysEqual(this.x.shape, this.target.shape), + 'Error adding softmaxCrossEntropyCost op: x shape (' + this.x.shape + + ') must match target shape (' + this.target.shape + ').'); + } +} + +/** + * @hidden + */ +export class SoftmaxNode extends Node { + static readonly X = 'x'; + + constructor(graph: Graph, private x: Tensor) { + super(graph, 'Softmax', {x}, new Tensor(x.shape)); + } + validate() { + util.assert( + this.x.shape.length === 1, + 'The input to a softmax must be a 1-D tensor'); + util.assert( + this.x.shape[0] >= 2, + 'The input to a softmax must have at least 2 values'); + } +} + +/** + * MeanSquaredCostNode represents a mean squared cost operation + * in the graph. + * + * @hidden + */ +export class MeanSquaredCostNode extends Node { + static readonly LABEL = 'label'; + static readonly PREDICTION = 'prediction'; + constructor(graph: Graph, private label: Tensor, private prediction: Tensor) { + super(graph, 'Mean Squared Cost', {label, prediction}, new Tensor([])); + } + validate() { + util.assert( + util.arraysEqual(this.label.shape, this.prediction.shape), + 'Error adding meanSquaredCost op: label shape (' + this.label.shape + + ') must match prediction shape (' + this.prediction.shape + ').'); + } +} + +/** + * ArgMaxNode represents an argmax operation in the graph. + * @hidden + */ +export class ArgMaxNode extends Node { + static readonly X = 'x'; + constructor(graph: Graph, public x: Tensor) { + super(graph, 'ArgMax', {x}, new Tensor([1])); + } + validate() { + util.assert( + util.sizeFromShape(this.x.shape) > 0, + 'Error adding argmax op: input tensor must have at least one entry.'); + } +} + +/** + * ArgMaxEqualsNode represents a argmax equals operation in the graph. + * @hidden + */ +export class ArgMaxEqualsNode extends Node { + static readonly X1 = 'x1'; + static readonly X2 = 'x2'; + constructor(graph: Graph, private x1: Tensor, private x2: Tensor) { + super(graph, 'ArgMaxEquals', {x1, x2}, new Tensor([1])); + } + validate() { + util.assert( + util.arraysEqual(this.x1.shape, this.x2.shape), + 'Error adding ArgMaxEquals op: x1 shape (' + this.x1.shape + + ') must match x2 shape (' + this.x2.shape + ').'); + } +} + +/** + * Split nodes are used to accumulate backprop derivatives when a node's output + * tensor is consumed by multiple nodes. + * @hidden + */ +export class SplitNode extends Node { + static readonly X = 'x'; + + outputs: Tensor[] = []; + + constructor(graph: Graph, x: Tensor) { + super(graph, 'SplitNode', {x}, new Tensor(x.shape)); + } + + /** + * Registers a new consumer of this split node, i.e. a new node that uses the + * node's output tensor. + */ + getNewOutputTensor(): Tensor { + const output = new Tensor(this.inputs[SplitNode.X].shape); + output.node = this; + this.outputs.push(output); + return output; + } + validate() {} +} + +/** + * @hidden + */ +export type ArrayData = + NDArray|number|number[]|number[][]|number[][][]|number[][][][]; diff --git a/src/graph_layers.ts b/src/graph_layers.ts new file mode 100644 index 0000000000..fe0c8c4225 --- /dev/null +++ b/src/graph_layers.ts @@ -0,0 +1,51 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Graph, Tensor} from './graph'; +import {Initializer, VarianceScalingInitializer, ZerosInitializer} from './initializers'; +import {NDArray} from './math/ndarray'; + +/** + * A layers sugar class around the graph that initializes variables + * automatically for layers. + */ +export class GraphLayers { + constructor(private g: Graph) {} + + dense( + name: string, x: Tensor, units: number, + activation: ((x: Tensor) => Tensor)|null = null, useBias = true, + kernelInitializer: Initializer = new VarianceScalingInitializer(), + biasInitializer: Initializer = new ZerosInitializer()) { + const weights = this.g.variable( + name + '-weights', + kernelInitializer.initialize([x.shape[0], units], x.shape[0], units)); + + let out = this.g.matmul(x, weights); + + if (useBias) { + const bias = this.g.variable( + name + '-bias', + biasInitializer.initialize([units], x.shape[0], units)); + out = this.g.add(out, bias); + } + + if (activation != null) { + out = activation(out); + } + + return out; + } +} diff --git a/src/graph_runner.ts b/src/graph_runner.ts new file mode 100644 index 0000000000..9bb0c0d4ed --- /dev/null +++ b/src/graph_runner.ts @@ -0,0 +1,357 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as dataset from './dataset'; +import {Graph, Tensor} from './graph'; +import {InputProvider} from './input_provider'; +import {NDArrayMath} from './math/math'; +import {NDArrayMathCPU} from './math/math_cpu'; +import {NDArray, Scalar} from './math/ndarray'; +import {Optimizer} from './optimizer'; +import {CostReduction, FeedEntry, Session} from './session'; + +const DEFAULT_EVAL_INTERVAL_MS = 1500; +const DEFAULT_COST_INTERVAL_MS = 500; +const DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS = 3000; + +export interface GraphRunnerEventObserver { + batchesTrainedCallback?: (totalBatchesTrained: number) => void; + avgCostCallback?: (avgCost: Scalar) => void; + metricCallback?: (metric: NDArray) => void; + inferenceExamplesCallback?: + (feeds: FeedEntry[][], inferenceValues: NDArray[]) => void; + inferenceExamplesPerSecCallback?: (examplesPerSec: number) => void; + trainExamplesPerSecCallback?: (examplesPerSec: number) => void; + totalTimeCallback?: (totalTimeSec: number) => void; + doneTrainingCallback?: () => void; +} + +export enum MetricReduction { + SUM, + MEAN +} + +/** + * A class that drives the training of a graph model given a dataset. It allows + * the user to provide a set of callbacks for measurements like cost, accuracy, + * and speed of training. + */ +export class GraphRunner { + private costTensor: Tensor; + private trainFeedEntries: FeedEntry[]; + private batchSize: number; + private optimizer: Optimizer; + private currentTrainLoopNumBatches: number|undefined; + private costIntervalMs: number; + + private metricTensor: Tensor|undefined; + private metricFeedEntries: FeedEntry[]|undefined; + private metricBatchSize: number|undefined; + private metricReduction: MetricReduction; + private metricIntervalMs: number; + + private inferenceTensor: Tensor; + private inferenceFeedEntries: FeedEntry[]|undefined; + private inferenceExampleIntervalMs: number; + private inferenceExampleCount: number; + + // Runtime information. + private isTraining: boolean; + private totalBatchesTrained: number; + private batchesTrainedThisRun: number; + private lastComputedMetric: NDArray; + + private isInferring: boolean; + private currentInferenceLoopNumPasses: number|undefined; + private inferencePassesThisRun: number; + + private trainStartTimestamp: number; + private lastCostTimestamp = 0; + private lastEvalTimestamp = 0; + + private lastStopTimestamp: number|null; + private totalIdleTimeMs = 0; + + private zeroScalar: Scalar; + private metricBatchSizeScalar: Scalar; + + constructor( + private math: NDArrayMath, private session: Session, + private eventObserver: GraphRunnerEventObserver) { + this.resetStatistics(); + this.zeroScalar = Scalar.new(0); + } + + resetStatistics() { + this.totalBatchesTrained = 0; + this.totalIdleTimeMs = 0; + this.lastStopTimestamp = null; + } + + /** + * Start the training loop with an optional number of batches to train for. + * Optionally takes a metric tensor and feed entries to compute periodically. + * This can be used for computing accuracy, or a similar metric. + */ + train( + costTensor: Tensor, trainFeedEntries: FeedEntry[], batchSize: number, + optimizer: Optimizer, numBatches?: number, metricTensor?: Tensor, + metricFeedEntries?: FeedEntry[], metricBatchSize?: number, + metricReduction = MetricReduction.MEAN, + evalIntervalMs = DEFAULT_EVAL_INTERVAL_MS, + costIntervalMs = DEFAULT_COST_INTERVAL_MS) { + this.costTensor = costTensor; + this.trainFeedEntries = trainFeedEntries; + this.metricTensor = metricTensor; + this.metricFeedEntries = metricFeedEntries; + if (metricBatchSize != null && this.metricBatchSize !== metricBatchSize) { + if (this.metricBatchSizeScalar != null) { + this.metricBatchSizeScalar.dispose(); + } + this.metricBatchSizeScalar = Scalar.new(metricBatchSize); + } + this.metricBatchSize = metricBatchSize; + this.metricReduction = metricReduction; + this.batchSize = batchSize; + this.optimizer = optimizer; + + this.metricIntervalMs = evalIntervalMs; + this.costIntervalMs = costIntervalMs; + this.currentTrainLoopNumBatches = numBatches; + + this.batchesTrainedThisRun = 0; + this.isTraining = true; + this.trainStartTimestamp = performance.now(); + this.trainNetwork(); + } + + stopTraining() { + this.isTraining = false; + this.lastStopTimestamp = performance.now(); + } + + resumeTraining() { + this.isTraining = true; + if (this.lastStopTimestamp != null) { + this.totalIdleTimeMs += performance.now() - this.lastStopTimestamp; + } + this.trainNetwork(); + } + + private trainNetwork() { + if (this.batchesTrainedThisRun === this.currentTrainLoopNumBatches) { + this.stopTraining(); + } + + if (!this.isTraining) { + if (this.eventObserver.doneTrainingCallback != null) { + this.eventObserver.doneTrainingCallback(); + } + return; + } + + const start = performance.now(); + const shouldComputeCost = this.eventObserver.avgCostCallback != null && + (start - this.lastCostTimestamp > this.costIntervalMs); + if (shouldComputeCost) { + this.lastCostTimestamp = start; + } + + const costReduction = + shouldComputeCost ? CostReduction.MEAN : CostReduction.NONE; + + this.math.scope((keep) => { + const avgCost = this.session.train( + this.costTensor, this.trainFeedEntries, this.batchSize, + this.optimizer, costReduction); + + if (shouldComputeCost) { + const trainTime = performance.now() - start; + + this.eventObserver.avgCostCallback!(avgCost); + + if (this.eventObserver.trainExamplesPerSecCallback != null) { + const examplesPerSec = (this.batchSize * 1000 / trainTime); + this.eventObserver.trainExamplesPerSecCallback(examplesPerSec); + } + } + + if (this.eventObserver.metricCallback != null && + this.metricFeedEntries != null && + start - this.lastEvalTimestamp > this.metricIntervalMs) { + this.lastEvalTimestamp = start; + + if (this.lastComputedMetric != null) { + this.lastComputedMetric.dispose(); + } + this.lastComputedMetric = this.computeMetric(); + this.eventObserver.metricCallback(this.lastComputedMetric); + } + + if (this.eventObserver.totalTimeCallback != null) { + this.eventObserver.totalTimeCallback( + (start - this.trainStartTimestamp) / 1000); + } + + this.batchesTrainedThisRun++; + this.totalBatchesTrained++; + + if (this.eventObserver.batchesTrainedCallback != null) { + this.eventObserver.batchesTrainedCallback(this.totalBatchesTrained); + } + + }); + setTimeout(() => this.trainNetwork()); + } + + infer( + inferenceTensor: Tensor, inferenceFeedEntries: FeedEntry[], + inferenceExampleIntervalMs = DEFAULT_INFERENCE_EXAMPLE_INTERVAL_MS, + inferenceExampleCount = 5, numPasses?: number) { + if (this.eventObserver.inferenceExamplesCallback == null && + this.eventObserver.inferenceExamplesPerSecCallback == null) { + throw new Error( + 'Cannot start inference loop, no inference example or ' + + 'examples/sec observer provided.'); + } + + // Make sure the feed values are providers, and not NDArrays. + for (let i = 0; i < inferenceFeedEntries.length; i++) { + const feedEntry = inferenceFeedEntries[i]; + + if (feedEntry.data instanceof NDArray) { + throw new Error( + 'Cannot start inference on the model runner with feed entries of ' + + 'type NDArray. Please use InputProviders.'); + } + } + + this.inferenceExampleIntervalMs = inferenceExampleIntervalMs; + this.inferenceTensor = inferenceTensor; + this.inferenceFeedEntries = inferenceFeedEntries; + this.inferenceExampleCount = inferenceExampleCount; + this.currentInferenceLoopNumPasses = numPasses; + if (!this.isInferring) { + this.inferencePassesThisRun = 0; + setTimeout(() => this.inferNetwork()); + } + this.isInferring = true; + } + + private inferNetwork() { + if (!this.isInferring || + this.inferencePassesThisRun === this.currentInferenceLoopNumPasses) { + return; + } + + this.math.scope((keep, track) => { + const feeds: FeedEntry[][] = []; + const inferenceValues: NDArray[] = []; + + const start = performance.now(); + for (let i = 0; i < this.inferenceExampleCount; i++) { + // Populate a new FeedEntry[] populated with NDArrays. + const ndarrayFeedEntries: FeedEntry[] = []; + for (let j = 0; j < this.inferenceFeedEntries!.length; j++) { + const feedEntry = this.inferenceFeedEntries![j]; + ndarrayFeedEntries.push({ + tensor: feedEntry.tensor, + data: + track((feedEntry.data as InputProvider).getNextCopy(this.math)) + }); + } + feeds.push(ndarrayFeedEntries); + + inferenceValues.push( + this.session.eval(this.inferenceTensor, ndarrayFeedEntries)); + } + + if (this.eventObserver.inferenceExamplesPerSecCallback != null) { + // Force a GPU download, since inference results are generally needed on + // the CPU and it's more fair to include blocking on the GPU to complete + // its work for the inference measurement. + inferenceValues[inferenceValues.length - 1].getValues(); + + const inferenceExamplesPerSecTime = performance.now() - start; + + const examplesPerSec = + (this.inferenceExampleCount * 1000 / inferenceExamplesPerSecTime); + this.eventObserver.inferenceExamplesPerSecCallback!(examplesPerSec); + } + + if (this.eventObserver.inferenceExamplesCallback != null) { + this.eventObserver.inferenceExamplesCallback(feeds, inferenceValues); + } + this.inferencePassesThisRun++; + + }); + setTimeout(() => this.inferNetwork(), this.inferenceExampleIntervalMs); + } + + stopInferring() { + this.isInferring = false; + } + + isInferenceRunning(): boolean { + return this.isInferring; + } + + computeMetric(): Scalar { + if (this.metricFeedEntries == null) { + throw new Error('Cannot compute metric, no metric FeedEntries provided.'); + } + + let metric = this.zeroScalar; + + return this.math.scope((keep) => { + for (let i = 0; i < this.metricBatchSize!; i++) { + const metricValue = + this.session.eval(this.metricTensor!, this.metricFeedEntries!); + + metric = this.math.add(metric, metricValue); + } + + if (this.metricReduction === MetricReduction.MEAN) { + metric = this.math.divide(metric, this.metricBatchSizeScalar); + } + + return metric; + }); + } + + getTotalBatchesTrained(): number { + return this.totalBatchesTrained; + } + + getLastComputedMetric(): Scalar { + return this.lastComputedMetric; + } + + setMath(math: NDArrayMath) { + this.math = math; + } + + setSession(session: Session) { + this.session = session; + } + + setInferenceTensor(inferenceTensor: Tensor) { + this.inferenceTensor = inferenceTensor; + } + + setInferenceExampleCount(inferenceExampleCount: number) { + this.inferenceExampleCount = inferenceExampleCount; + } +} diff --git a/src/graph_runner_test.ts b/src/graph_runner_test.ts new file mode 100644 index 0000000000..b73cb61f36 --- /dev/null +++ b/src/graph_runner_test.ts @@ -0,0 +1,204 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Graph, Tensor} from './graph'; +import {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner'; +import {NDArrayMath} from './math/math'; +import {NDArrayMathCPU} from './math/math_cpu'; +import {Array1D, NDArray, Scalar} from './math/ndarray'; +import {Optimizer} from './optimizer'; +import {CostReduction, FeedEntry, Session} from './session'; +import {SGDOptimizer} from './sgd_optimizer'; + +const FAKE_LEARNING_RATE = 1.0; +const FAKE_BATCH_SIZE = 10; + +function fakeTrainBatch( + math: NDArrayMath, feedEntries: FeedEntry[], batchSize: number, + optimizer: Optimizer, costReduction: CostReduction) { + return Scalar.new(.5); +} + +describe('Model runner', () => { + let math: NDArrayMath; + let g: Graph; + let session: Session; + let optimizer: SGDOptimizer; + let inputTensor: Tensor; + let labelTensor: Tensor; + let costTensor: Tensor; + let predictionTensor: Tensor; + let metricTensor: Tensor; + + let graphRunner: GraphRunner; + + let avgCostCallback: (avgCost: Scalar) => void; + let metricCallback: (metric: Scalar) => void; + + const fakeUserEvents: GraphRunnerEventObserver = { + batchesTrainedCallback: (totalBatchesTrained: number) => null, + avgCostCallback: (avgCost: Scalar) => avgCostCallback(avgCost), + metricCallback: (metric: Scalar) => metricCallback(metric), + inferenceExamplesCallback: + (feeds: FeedEntry[][], inferenceValues: NDArray[]) => null, + trainExamplesPerSecCallback: (examplesPerSec: number) => null, + totalTimeCallback: (totalTime: number) => null + }; + + beforeEach(() => { + math = new NDArrayMathCPU(); + g = new Graph(); + optimizer = new SGDOptimizer(FAKE_LEARNING_RATE); + + inputTensor = g.placeholder('input', [2]); + + predictionTensor = g.add(inputTensor, g.constant(Array1D.new([1, 1]))); + + labelTensor = g.placeholder('label', [2]); + + costTensor = g.softmaxCrossEntropyCost(predictionTensor, labelTensor); + + metricTensor = g.argmaxEquals(predictionTensor, labelTensor); + + session = new Session(g, math); + + spyOn(session, 'train').and.callFake(fakeTrainBatch); + let counter = 0; + spyOn(session, 'eval').and.callFake((evalTensor: Tensor) => { + if (evalTensor === predictionTensor) { + return Array1D.new([1, 0]); + } else if (evalTensor === metricTensor) { + return Scalar.new(counter++ % 2); + } else { + throw new Error('Eval tensor not recognized'); + } + }); + spyOn(fakeUserEvents, 'batchesTrainedCallback').and.callThrough(); + spyOn(fakeUserEvents, 'avgCostCallback').and.callThrough(); + spyOn(fakeUserEvents, 'metricCallback').and.callThrough(); + spyOn(fakeUserEvents, 'inferenceExamplesCallback').and.callThrough(); + spyOn(fakeUserEvents, 'trainExamplesPerSecCallback').and.callThrough(); + spyOn(fakeUserEvents, 'totalTimeCallback').and.callThrough(); + }); + + it('basic train usage, train 3 batches', (doneFn) => { + const numBatches = 3; + const trainFeedEntries: FeedEntry[] = []; + const testExampleProvider: FeedEntry[] = []; + + // Mark this async test as done once the model runner calls our callback, + // and fail if it doesn't. + fakeUserEvents.doneTrainingCallback = () => { + for (let i = 0; i < numBatches; i++) { + // All batches should compute cost. + const args = (session.train as jasmine.Spy).calls.argsFor(i); + expect(args).toEqual([ + costTensor, trainFeedEntries, FAKE_BATCH_SIZE, optimizer, + CostReduction.MEAN + ]); + + const avgCost = + (fakeUserEvents.avgCostCallback as jasmine.Spy).calls.argsFor(i)[0]; + const accuracy = + (fakeUserEvents.metricCallback as jasmine.Spy).calls.argsFor(i)[0]; + } + expect((fakeUserEvents.avgCostCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect((fakeUserEvents.metricCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect((session.train as jasmine.Spy).calls.count()).toEqual(numBatches); + + // 2 test examples are provided per batch. + expect((session.eval as jasmine.Spy).calls.count()) + .toEqual(FAKE_BATCH_SIZE * numBatches); + expect((fakeUserEvents.avgCostCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect((fakeUserEvents.metricCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect((fakeUserEvents.trainExamplesPerSecCallback as jasmine.Spy) + .calls.count()) + .toEqual(numBatches); + expect((fakeUserEvents.totalTimeCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect( + (fakeUserEvents.batchesTrainedCallback as jasmine.Spy).calls.count()) + .toEqual(numBatches); + expect(graphRunner.getTotalBatchesTrained()).toEqual(numBatches); + + // Inference callbacks should not be called during training. + expect((fakeUserEvents.inferenceExamplesCallback as jasmine.Spy) + .calls.count()) + .toEqual(0); + + doneFn(); + }; + + avgCostCallback = (avgCost: Scalar) => { + expect(avgCost.get()).toEqual(.5); + }; + metricCallback = (metric: Scalar) => { + expect(metric.get()).toEqual(.5); + }; + + + graphRunner = new GraphRunner(math, session, fakeUserEvents); + + expect(graphRunner.getTotalBatchesTrained()).toEqual(0); + + graphRunner.train( + costTensor, trainFeedEntries, FAKE_BATCH_SIZE, optimizer, numBatches, + metricTensor, testExampleProvider, FAKE_BATCH_SIZE, + MetricReduction.MEAN, 0, 0); + }); + + it('basic inference usage', (doneFn) => { + const intervalMs = 0; + const exampleCount = 2; + const numPasses = 1; + + fakeUserEvents.inferenceExamplesCallback = + (inputInferenceExamples: FeedEntry[][], + inferenceOutputs: NDArray[]) => { + expect(inputInferenceExamples.length).toEqual(exampleCount); + expect(inferenceOutputs.length).toEqual(exampleCount); + expect((session.eval as jasmine.Spy).calls.count()) + .toEqual(exampleCount * numPasses); + + // No training should have occured. + expect(graphRunner.getTotalBatchesTrained()).toEqual(0); + expect((fakeUserEvents.avgCostCallback as jasmine.Spy).calls.count()) + .toEqual(0); + expect((fakeUserEvents.metricCallback as jasmine.Spy).calls.count()) + .toEqual(0); + expect((fakeUserEvents.trainExamplesPerSecCallback as jasmine.Spy) + .calls.count()) + .toEqual(0); + expect( + (fakeUserEvents.totalTimeCallback as jasmine.Spy).calls.count()) + .toEqual(0); + expect((fakeUserEvents.batchesTrainedCallback as jasmine.Spy) + .calls.count()) + .toEqual(0); + expect(graphRunner.getTotalBatchesTrained()).toEqual(0); + doneFn(); + }; + graphRunner = new GraphRunner(math, session, fakeUserEvents); + + const inferenceFeedEntries: FeedEntry[] = []; + graphRunner.infer( + predictionTensor, inferenceFeedEntries, intervalMs, exampleCount, + numPasses); + }); +}); diff --git a/src/graph_test.ts b/src/graph_test.ts new file mode 100644 index 0000000000..8d9c5d5df1 --- /dev/null +++ b/src/graph_test.ts @@ -0,0 +1,621 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {ConstantNode, Graph, Node, Tensor, VariableNode} from './graph'; +import * as conv_util from './math/conv_util'; +import {NDArray} from './math/ndarray'; +import {FeedDictionary, Session} from './session'; +import * as session_util from './session_util'; + +class TestNode extends Node { + validate() {} +} + +describe('Graph', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('nodes have ascending ids', () => { + const a = new TestNode(g, '', {}, new Tensor([])); + const b = new TestNode(g, '', {}, new Tensor([])); + expect(b.id).toEqual(a.id + 1); + }); + + it('variable creates a node in the graph', () => { + const v = g.variable('', NDArray.zeros([1])); + expect(v.node.graph).toEqual(g); + }); + + it('variable creates a VariableNode in the graph', () => { + const v = g.variable('', NDArray.zeros([1])); + expect(v.node instanceof VariableNode).toEqual(true); + }); + + it('variable passes name to graph node', () => { + const v = g.variable('hello', NDArray.zeros([1])); + expect(v.node.name).toEqual('hello'); + }); + + it('mnist fully-connected', () => { + const input = g.placeholder('input', [28 * 28]); + const fc0W = g.variable('fc0W', NDArray.zeros([32, 28 * 28])); + const fc0B = g.variable('fc0B', NDArray.zeros([32])); + const fc0 = g.add(g.matmul(fc0W, input), fc0B); + const relu0 = g.relu(fc0); + const fc1W = g.variable('fc1W', NDArray.zeros([32, 32])); + const fc1B = g.variable('fc1B', NDArray.zeros([32])); + const fc1 = g.add(g.matmul(fc1W, relu0), fc1B); + const relu1 = g.relu(fc1); + const fc2W = g.variable('fc2W', NDArray.zeros([32, 32])); + const fc2B = g.variable('fc2B', NDArray.zeros([32])); + const fc2 = g.add(g.matmul(fc2W, relu1), fc2B); + const relu2 = g.relu(fc2); + const fc3W = g.variable('fc3W', NDArray.zeros([10, 32])); + const fc3B = g.variable('fc3B', NDArray.zeros([10])); + const fc3 = g.add(g.matmul(fc3W, relu2), fc3B); + + const fd = new FeedDictionary([{tensor: input, data: NDArray.zeros([1])}]); + const orderedEvaluationSet = + session_util.getOrderedEvaluationSetFromEvalTensor([fc3], fd); + }); +}); + +describe('Variable validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('null data throws', () => { + expect(() => g.variable('test', null!)).toThrowError(); + }); + + it('non null data does not throw', () => { + g.variable('test', NDArray.zeros([5])); + }); +}); + +describe('Placeholder validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('does not throw', () => { + expect(g.placeholder('test', [1, 2, 3]).shape).toEqual([1, 2, 3]); + }); +}); + +describe('Constant', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('null data throws', () => { + expect(() => g.constant(null!)).toThrowError(); + }); + + it('non null data does not throw', () => { + expect(g.constant(NDArray.zeros([5])).shape).toEqual([5]); + }); + + it('from a single value', () => { + const c = g.constant(3); + expect(c.shape).toEqual([]); + const values = (c.node as ConstantNode).data.getValues(); + expect(values).toEqual(new Float32Array([3])); + }); + + it('from 1d array', () => { + const c = g.constant([1, 2, 3]); + expect(c.shape).toEqual([3]); + const values = (c.node as ConstantNode).data.getValues(); + expect(values).toEqual(new Float32Array([1, 2, 3])); + }); + + it('from 2d array', () => { + const c = g.constant([[1, 2, 3], [4, 5, 6]]); + expect(c.shape).toEqual([2, 3]); + const values = (c.node as ConstantNode).data.getValues(); + expect(values).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('from 3d array', () => { + const c = g.constant([[[1], [2], [3]], [[4], [5], [6]]]); + expect(c.shape).toEqual([2, 3, 1]); + const values = (c.node as ConstantNode).data.getValues(); + expect(values).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('from 4d array', () => { + const c = g.constant([[[[1]], [[2]], [[3]]], [[[4]], [[5]], [[6]]]]); + expect(c.shape).toEqual([2, 3, 1, 1]); + const values = (c.node as ConstantNode).data.getValues(); + expect(values).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); +}); + +describe('Reshape validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different sizes throws', () => { + expect(() => g.reshape(new Tensor([5, 4]), [3, 3])).toThrowError(); + }); + + it('Same size does not throw', () => { + expect(g.reshape(new Tensor([5, 4]), [20]).shape).toEqual([20]); + }); +}); + +describe('FusedLinearCombination validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different shape tensors throws', () => { + expect( + () => g.fusedLinearCombination( + new Tensor([3, 4]), new Tensor([1]), new Tensor([]), + new Tensor([]))) + .toThrowError(); + }); + + it('Non scalar c1 throws', () => { + expect( + () => g.fusedLinearCombination( + new Tensor([3, 4]), new Tensor([3, 4]), new Tensor([1, 2]), + new Tensor([]))) + .toThrowError(); + }); + + it('Non scalar c2 throws', () => { + expect( + () => g.fusedLinearCombination( + new Tensor([3, 4]), new Tensor([3, 4]), new Tensor([]), + new Tensor([1, 2]))) + .toThrowError(); + }); + + it('does not throw when shapes correct', () => { + expect(g.fusedLinearCombination( + new Tensor([3, 4]), new Tensor([3, 4]), new Tensor([]), + new Tensor([])) + .shape) + .toEqual([3, 4]); + }); +}); + +describe('Add validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different shapes throws', () => { + expect(() => g.add(new Tensor([5, 4]), new Tensor([1, 2, 3]))) + .toThrowError(); + }); + + it('Same size does not throw', () => { + expect(g.add(new Tensor([5, 4]), new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('Subtract validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different shapes throws', () => { + expect(() => g.subtract(new Tensor([5, 4]), new Tensor([1, 2, 3]))) + .toThrowError(); + }); + + it('Same size does not throw', () => { + expect(g.subtract(new Tensor([5, 4]), new Tensor([5, 4])).shape).toEqual([ + 5, 4 + ]); + }); +}); + +describe('Multiply validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different shapes throws', () => { + expect(() => g.multiply(new Tensor([5, 4]), new Tensor([1, 2, 3]))) + .toThrowError(); + }); + + it('Same size does not throw', () => { + expect(g.multiply(new Tensor([5, 4]), new Tensor([5, 4])).shape).toEqual([ + 5, 4 + ]); + }); +}); + +describe('Divide validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Different shapes throws', () => { + expect(() => g.divide(new Tensor([5, 4]), new Tensor([1, 2, 3]))) + .toThrowError(); + }); + + it('Same size does not throw', () => { + expect(g.divide(new Tensor([5, 4]), new Tensor([5, 4])).shape).toEqual([ + 5, 4 + ]); + }); +}); + +describe('Reduce sum validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('does not throw', () => { + expect(g.reduceSum(new Tensor([5, 4, 4, 9])).shape).toEqual([]); + }); +}); + +describe('Concat3d validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Non 3-rank tensor x1 throws', () => { + expect(() => g.concat3d(new Tensor([5, 4]), new Tensor([1, 2, 3]), 0)) + .toThrowError(); + }); + + it('Non 3-rank tensor x2 throws', () => { + expect(() => g.concat3d(new Tensor([5, 4, 1]), new Tensor([1, 2]), 0)) + .toThrowError(); + }); + + it('Axis=0 different shapes throws', () => { + expect(() => g.concat3d(new Tensor([5, 4, 1]), new Tensor([1, 2, 1]), 0)) + .toThrowError(); + }); + + it('Axis=1 different shapes throws', () => { + expect(() => g.concat3d(new Tensor([5, 4, 1]), new Tensor([1, 2, 1]), 0)) + .toThrowError(); + }); + + it('Axis=2 different shapes throws', () => { + expect(() => g.concat3d(new Tensor([5, 4, 1]), new Tensor([1, 2, 1]), 0)) + .toThrowError(); + }); + + it('Axis=0 shapes the same does not throw', () => { + expect(g.concat3d(new Tensor([5, 4, 3]), new Tensor([1, 4, 3]), 0).shape) + .toEqual([6, 4, 3]); + }); + + it('Axis=1 shapes the same does not throw', () => { + expect(g.concat3d(new Tensor([5, 3, 3]), new Tensor([5, 4, 3]), 1).shape) + .toEqual([5, 7, 3]); + }); + + it('Axis=2 shapes the same does not throw', () => { + expect(g.concat3d(new Tensor([5, 4, 3]), new Tensor([5, 4, 1]), 2).shape) + .toEqual([5, 4, 4]); + }); +}); + +describe('matmul validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Wrong rank x1 throws', () => { + expect(() => g.matmul(new Tensor([5, 4, 3]), new Tensor([1, 2]))) + .toThrowError(); + }); + + it('Wrong rank x2 throws', () => { + expect(() => g.matmul(new Tensor([5, 4]), new Tensor([1, 2, 3]))) + .toThrowError(); + }); + + it('Inner dimensions of matrix multiply do not match throws', () => { + expect(() => g.matmul(new Tensor([5, 4]), new Tensor([5, 5]))) + .toThrowError(); + }); + + it('Inner dimensions of matrix times vector does not match throws', () => { + expect(() => g.matmul(new Tensor([5, 4]), new Tensor([5]))).toThrowError(); + }); + + it('Inner dimensions of vector times matrix does not match throws', () => { + expect(() => g.matmul(new Tensor([5]), new Tensor([4, 5]))).toThrowError(); + }); + + it('Vector times vector shapes dont match throws', () => { + expect(() => g.matmul(new Tensor([5]), new Tensor([4]))).toThrowError(); + }); + + it('Matrix times matrix inner dimensions match does not throw', () => { + expect(g.matmul(new Tensor([5, 4]), new Tensor([4, 6])).shape).toEqual([ + 5, 6 + ]); + }); + + it('Vector times matrix inner dimensions match does not throw', () => { + expect(g.matmul(new Tensor([4]), new Tensor([4, 6])).shape).toEqual([6]); + }); + + it('Matrix times vector inner dimensions match does not throw', () => { + expect(g.matmul(new Tensor([4, 6]), new Tensor([6])).shape).toEqual([4]); + }); +}); + +describe('conv2d validation', () => { + let g: Graph; + let fieldSize: number; + let outputDepth: number; + let stride: number; + let zeroPad: number; + + beforeEach(() => { + g = new Graph(); + fieldSize = 4; + outputDepth = 10; + stride = 1; + zeroPad = 1; + }); + + it('Wrong rank x throws', () => { + expect( + () => g.conv2d( + new Tensor([5, 4]), new Tensor([1, 2, 3, 4]), + new Tensor([outputDepth]), fieldSize, outputDepth, stride, zeroPad)) + .toThrowError(); + }); + + it('Wrong rank weights throws', () => { + expect( + () => g.conv2d( + new Tensor([5, 4, 3]), new Tensor([1, 2, 3]), + new Tensor([outputDepth]), fieldSize, outputDepth, stride, zeroPad)) + .toThrowError(); + }); + + it('Wrong rank biases throws', () => { + expect( + () => g.conv2d( + new Tensor([5, 4, 3]), new Tensor([1, 2, 3, 4]), new Tensor([5, 5]), + fieldSize, outputDepth, stride, zeroPad)) + .toThrowError(); + }); + + it('Input depths dont match throws', () => { + expect( + () => g.conv2d( + new Tensor([5, 4, 3]), new Tensor([1, 2, 100, 4]), + new Tensor([outputDepth]), fieldSize, outputDepth, stride, zeroPad)) + .toThrowError(); + }); + + it('Shapes matches does not throw', () => { + const expectedShape = conv_util.computeOutputShape3D( + [5, 4, 3], fieldSize, outputDepth, stride, zeroPad); + expect(g.conv2d( + new Tensor([5, 4, 3]), new Tensor([1, 2, 3, 4]), + new Tensor([outputDepth]), fieldSize, outputDepth, stride, + zeroPad) + .shape) + .toEqual(expectedShape); + }); +}); + +describe('maxpool validation', () => { + let g: Graph; + let fieldSize: number; + let stride: number; + let zeroPad: number; + + beforeEach(() => { + g = new Graph(); + fieldSize = 4; + stride = 1; + zeroPad = 1; + }); + + it('Wrong rank x throws', () => { + expect(() => g.maxPool(new Tensor([5, 4]), fieldSize, stride, zeroPad)) + .toThrowError(); + }); + + it('Shapes matches does not throw', () => { + const expectedShape = conv_util.computeOutputShape3D( + [5, 4, 3], fieldSize, 3, stride, zeroPad); + expect(g.maxPool(new Tensor([5, 4, 3]), fieldSize, stride, zeroPad).shape) + .toEqual(expectedShape); + }); +}); + +describe('relu validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.relu(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('exp validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.exp(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('log validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.log(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('tanh validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.tanh(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('sigmoid validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.sigmoid(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('square validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Does not throw', () => { + expect(g.square(new Tensor([5, 4])).shape).toEqual([5, 4]); + }); +}); + +describe('softmaxCrossEntropy validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Shapes not equal throws', () => { + expect( + () => g.softmaxCrossEntropyCost( + new Tensor([5, 4]), new Tensor([5, 4, 3]))) + .toThrowError(); + }); + + it('Does not throw', () => { + expect( + g.softmaxCrossEntropyCost(new Tensor([5, 4]), new Tensor([5, 4])).shape) + .toEqual([]); + }); +}); + +describe('meanSquaredCost validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Shapes not equal throws', () => { + expect(() => g.meanSquaredCost(new Tensor([5, 4]), new Tensor([5, 4, 3]))) + .toThrowError(); + }); + + it('Does not throw', () => { + expect(g.meanSquaredCost(new Tensor([5, 4]), new Tensor([5, 4])).shape) + .toEqual([]); + }); +}); + +describe('argmaxEquals validation', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('Shapes not equal throws', () => { + expect(() => g.argmaxEquals(new Tensor([5, 4]), new Tensor([5, 4, 3]))) + .toThrowError(); + }); + + it('Does not throw', () => { + expect(g.argmaxEquals(new Tensor([5, 4]), new Tensor([5, 4])).shape) + .toEqual([1]); + }); +}); + +describe('Tensor', () => { + it('captures shape from constructor', () => { + const t = new Tensor([1, 2, 3, 4]); + expect(t.shape).toEqual([1, 2, 3, 4]); + }); + + it('has unique ascending ids', () => { + const a = new Tensor([]); + const b = new Tensor([]); + expect(b.id).toEqual(a.id + 1); + }); +}); diff --git a/src/graph_util.ts b/src/graph_util.ts new file mode 100644 index 0000000000..c1bd3c3137 --- /dev/null +++ b/src/graph_util.ts @@ -0,0 +1,132 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {ConstantNode, Graph, Node, PlaceholderNode, Tensor, VariableNode} from './graph'; +import * as priority_queue from './priority_queue'; +import {PriorityQueue} from './priority_queue'; +import {TensorArrayMap} from './tensor_array_map'; + +/** + * Given a target node in a graph, accumulate the set of all nodes that need to + * be evaluated in order to evaluate the target graph. Traversal stops anywhere + * a node's values are fed in externally via "feed dicts". + * @param nodes The nodes to be evaluated. + * @param terminatingNodes The set of nodes that stop traversal. + * @return The unordered set of nodes that need to be evaluated. + */ +export function getUnorderedEvaluationSet( + nodes: Node[], terminatingNodes: Node[]): Node[] { + const terminatingNodeMap: {[id: number]: Node} = {}; + const seen: {[id: number]: Node} = {}; + const set: Node[] = []; + const visit: Node[] = nodes.slice(); + terminatingNodes.forEach(node => terminatingNodeMap[node.id] = node); + /* Flood fill: While the 'to visit' stack is not empty, pop a node off of it. + * If the node has not yet been visited, add it to the set, mark it as seen, + * and enqueue all of its ancestor (input) nodes. */ + while (visit.length !== 0) { + const cur = visit.pop()!; + if (seen[cur.id] == null) { + if (terminatingNodeMap[cur.id] == null) { + Object.keys(cur.inputs) + .map(inputName => cur.inputs[inputName]) + .forEach(input => visit.push(input.node)); + } + set.push(cur); + seen[cur.id] = cur; + } + } + return set; +} + +/** + * Given a set of nodes, compute their order such that all dependent nodes are + * evaluated after their dependees. This is the 'inference order' for nodes in + * the operation graph. + * @param unorderedEvaluationSet The unordered set of nodes that need to be + * evaluated. + * @return The input nodes in forward evaluation order. + */ +export function getOrderedEvaluationSet(unorderedEvaluationSet: Node[]): + Node[] { + /* A priority queue is used, where the priority is the remaining number of + * unevaluated nodes whose inputs come from the element node. This guarantees + * that all downstream nodes will be dequeued before their ancestors. */ + const set: Node[] = []; + const nodeIndices: {[id: number]: number} = {}; + const pendingDependencies: {[id: number]: number} = {}; + + /* The queue priority callback looks at the number of pending dependencies of + * a given node. The queue index observer callback maintains the location of + * each node in the array, for priority updates. */ + const nodeQueue = new PriorityQueue( + (a: Node, b: Node) => priority_queue.defaultCompare( + pendingDependencies[a.id], pendingDependencies[b.id]), + (node: Node, newIndex: number) => nodeIndices[node.id] = newIndex); + + unorderedEvaluationSet.forEach(node => pendingDependencies[node.id] = 0); + + /* For every descendent of a node (output of ancestor is input to descendant), + * increment the 'pending dependency count' for the ancestor. This prepares + * the 'pending dependency count' as a priority map. */ + unorderedEvaluationSet.forEach( + node => Object.keys(node.inputs) + .map(key => node.inputs[key]) + .forEach(input => { + if (unorderedEvaluationSet.indexOf(input.node) !== -1) { + pendingDependencies[input.node.id]++; + } + })); + + unorderedEvaluationSet.forEach(node => nodeQueue.enqueue(node)); + + while (!nodeQueue.empty()) { + set.unshift(nodeQueue.dequeue()); + /* As each node is visited, decrement the 'pending dependency count' of + * each ancestor, and tell the priority queue that the priority has changed. + */ + Object.keys(set[0].inputs).map(key => set[0].inputs[key]).forEach(input => { + if (unorderedEvaluationSet.indexOf(input.node) === -1) { + return; + } + pendingDependencies[input.node.id]--; + nodeQueue.update(input.node, nodeIndices[input.node.id]); + }); + } + + return set; +} + +/** + * @return True iff the node is an input node. + */ +export function isInputNode(node: Node): boolean { + return Object.keys(node.inputs).length === 0; +} + +export function shouldBackProp(t: Tensor): boolean { + return !(t.node instanceof ConstantNode); +} + +export function isPassthroughNode(node: Node, map: TensorArrayMap): boolean { + const keys = Object.keys(node.inputs); + for (let i = 0; i < keys.length; i++) { + const input = node.inputs[keys[i]]; + if (map.get(input, true) === map.get(node.output, true)) { + return true; + } + } + return false; +} diff --git a/src/graph_util_test.ts b/src/graph_util_test.ts new file mode 100644 index 0000000000..7c48490e5c --- /dev/null +++ b/src/graph_util_test.ts @@ -0,0 +1,225 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {ConstantNode, Graph, Node, PlaceholderNode, ReLUNode, SplitNode, SquareNode, Tensor, VariableNode} from './graph'; +import * as graph_util from './graph_util'; +import {NDArray, Scalar} from './math/ndarray'; +import {TensorArrayMap} from './tensor_array_map'; + +class TestNode extends Node { + validate() {} +} + +describe('graph_util.getUnorderedEvaluationSet', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('returns only node in graph', () => { + const n = new TestNode(g, '', {}, new Tensor([])); + const path = graph_util.getUnorderedEvaluationSet([n], []); + expect(path.length).toEqual(1); + expect(path[0]).toBe(n); + }); + + it('returns both nodes in graph with two connected nodes', () => { + const t = new Tensor([]); + const s = new TestNode(g, '', {}, t); + const e = new TestNode(g, '', {'t': t}, new Tensor([])); + const path = graph_util.getUnorderedEvaluationSet([e], []); + expect(path.length).toEqual(2); + expect(path).toContain(s); + expect(path).toContain(e); + }); + + it('adds nodes in the termination set', () => { + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const n1 = new TestNode(g, '', {'t0': t0}, t1); + const n2 = new TestNode(g, '', {'t1': t1}, new Tensor([])); + const path = graph_util.getUnorderedEvaluationSet([n2], [n0]); + expect(path.length).toEqual(3); + expect(path).toContain(n0); + expect(path).toContain(n1); + expect(path).toContain(n2); + }); + + it('does not process inputs from nodes in the termination set', () => { + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const n1 = new TestNode(g, '', {'t0': t0}, t1); + const n2 = new TestNode(g, '', {'t1': t1}, new Tensor([])); + const path = graph_util.getUnorderedEvaluationSet([n2], [n1]); + expect(path.length).toEqual(2); + expect(path).toContain(n1); + expect(path).toContain(n2); + }); + + it('accumulates multiple inputs from nodes', () => { + const t0 = new Tensor([]); + const i0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const i1 = new TestNode(g, '', {}, t1); + const n = new TestNode(g, '', {'t0': t0, 't1': t1}, new Tensor([])); + const path = graph_util.getUnorderedEvaluationSet([n], []); + expect(path.length).toEqual(3); + expect(path).toContain(i0); + expect(path).toContain(i1); + expect(path).toContain(n); + }); + + it('enqueues each node once even if there are multiple paths to it', () => { + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const n1 = new TestNode(g, '', {'t0': t0}, t1); + const t2 = new Tensor([]); + const n2 = new TestNode(g, '', {'t0': t0}, t2); + const n3 = new TestNode(g, '', {'t1': t1, 't2': t2}, new Tensor([])); + const set = graph_util.getUnorderedEvaluationSet([n3], []); + expect(set.length).toEqual(4); + expect(set).toContain(n0); + expect(set).toContain(n1); + expect(set).toContain(n2); + expect(set).toContain(n3); + }); +}); + +describe('graph_util.getOrderedEvaluationSet', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('returns only node in unordered set', () => { + const n = new TestNode(g, '', {}, new Tensor([])); + expect(graph_util.getOrderedEvaluationSet([n])).toEqual([n]); + }); + + it('orders dependencies first (2 nodes)', () => { + // 0 => 1: [0 1] + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const n1 = new TestNode(g, '', {'t0': t0}, new Tensor([])); + const unordered = [n1, n0]; + const ordered = [n0, n1]; + expect(graph_util.getOrderedEvaluationSet(unordered)).toEqual(ordered); + }); + + it('orders dependencies first (3 nodes)', () => { + // 0 => 1, 1 => 2, 0 => 2: [0 1 2] + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const n1 = new TestNode(g, '', {'t0': t0}, t1); + const n2 = new TestNode(g, '', {'t0': t0, 't1': t1}, new Tensor([])); + const unordered = [n1, n2, n0]; + const ordered = [n0, n1, n2]; + expect(graph_util.getOrderedEvaluationSet(unordered)).toEqual(ordered); + }); + + it('orders dependencies first (5 nodes)', () => { + // 0 => 1, 0 => 2, 0 => 4 + // 1 => 3 + // 2 => 3 + // 3 => 4 + // [0 1 2 3 4] or [0 2 1 3 4] + const t0 = new Tensor([]); + const n0 = new TestNode(g, '', {}, t0); + const t1 = new Tensor([]); + const n1 = new TestNode(g, '', {'t0': t0}, t1); + const t2 = new Tensor([]); + const n2 = new TestNode(g, '', {'t0': t0}, t2); + const t3 = new Tensor([]); + const n3 = new TestNode(g, '', {'t1': t1, 't2': t2}, t3); + const t4 = new Tensor([]); + const n4 = new TestNode(g, '', {'t0': t0, 't3': t3}, new Tensor([])); + const path = graph_util.getOrderedEvaluationSet([n4, n3, n2, n1, n0]); + expect(path[0]).toBe(n0); + const n2n1 = (path[1] === n2) && (path[2] === n1); + const n1n2 = (path[1] === n1) && (path[2] === n2); + expect(n2n1 || n1n2).toBe(true); + expect(path[3]).toBe(n3); + expect(path[4]).toBe(n4); + }); +}); + +describe('graph_util.isInputNode', () => { + let g: Graph; + let nda: NDArray; + + beforeEach(() => { + g = new Graph(); + nda = NDArray.zeros([1]); + }); + + it('returns true for VariableNode', () => { + expect(graph_util.isInputNode(new VariableNode(g, '', nda))).toEqual(true); + }); + + it('returns true for PlaceholderNode', () => { + expect(graph_util.isInputNode(new PlaceholderNode(g, '', [1]))) + .toEqual(true); + }); + + it('returns true for ConstantNode', () => { + expect(graph_util.isInputNode(new ConstantNode(g, NDArray.zeros([1])))) + .toEqual(true); + }); + + it('returns false for ReLUNode', () => { + expect(graph_util.isInputNode(new ReLUNode(g, new Tensor([])))) + .toEqual(false); + }); +}); + +describe('graph_util.isPassthroughNode', () => { + let g: Graph; + + beforeEach(() => { + g = new Graph(); + }); + + it('returns false for a node that produces new NDArray', () => { + const x = g.placeholder('x', []); + const node = new SquareNode(g, x); + const map = new TensorArrayMap(); + const xVal = Scalar.new(3); + map.set(x, xVal); + const yVal = Scalar.new(9); + map.set(node.output, yVal); + + expect(graph_util.isPassthroughNode(node, map)).toBe(false); + xVal.dispose(); + yVal.dispose(); + }); + + it('returns true for a node that passes through the input', () => { + const x = g.placeholder('x', []); + const node = new SplitNode(g, x); + const map = new TensorArrayMap(); + const xVal = Scalar.new(3); + map.set(x, xVal); + map.set(node.output, xVal); + + expect(graph_util.isPassthroughNode(node, map)).toBe(true); + xVal.dispose(); + }); +}); diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000000..dea2fe7577 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,37 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from './math/conv_util'; +import * as gpgpu_util from './math/webgl/gpgpu_util'; +import * as render_ndarray_gpu_util from './math/webgl/render_ndarray_gpu_util'; +import * as webgl_util from './math/webgl/webgl_util'; +import * as util from './util'; + +export {CheckpointLoader} from './checkpoint_loader'; +export {DataStats, InMemoryDataset} from './dataset'; +export {Graph, Tensor} from './graph'; +export {GraphRunner, GraphRunnerEventObserver, MetricReduction} from './graph_runner'; +export {ConstantInitializer, Initializer, NDArrayInitializer, OnesInitializer, RandomNormalInitializer, RandomTruncatedNormalInitializer, RandomUniformInitializer, VarianceScalingInitializer, ZerosInitializer} from './initializers'; +export {InCPUMemoryShuffledInputProviderBuilder, InGPUMemoryShuffledInputProviderBuilder, InputProvider} from './input_provider'; +export {MatrixOrientation, NDArrayMath} from './math/math'; +export {NDArrayMathCPU} from './math/math_cpu'; +export {NDArrayMathGPU} from './math/math_gpu'; +export {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './math/ndarray'; +export {GPGPUContext} from './math/webgl/gpgpu_context'; +export {Optimizer} from './optimizer'; +export {CostReduction, FeedEntry, Session} from './session'; +export {SGDOptimizer} from './sgd_optimizer'; +// Second level exports. +export {conv_util, gpgpu_util, render_ndarray_gpu_util, util, webgl_util}; diff --git a/src/initializers.ts b/src/initializers.ts new file mode 100644 index 0000000000..52b1df5365 --- /dev/null +++ b/src/initializers.ts @@ -0,0 +1,125 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArray} from './math/ndarray'; + +/** + * Initializer interface, all initializer implement this interface. + */ +export interface Initializer { + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray; +} + +export class VarianceScalingInitializer implements Initializer { + constructor( + private scale = 1.0, + private mode: 'fan_in'|'fan_out'|'fan_avg' = 'fan_in', + private distribution: 'uniform'|'normal' = 'normal') {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + let n = 0; + if (this.mode === 'fan_in') { + n = inputUnits; + } else if (this.mode === 'fan_out') { + n = outputUnits; + } else if (this.mode === 'fan_avg') { + n = (inputUnits + outputUnits) / 2; + } else { + throw new Error( + 'Unexpected mode for variance scaling initializer: ' + this.mode); + } + + if (this.distribution === 'normal') { + return NDArray.randTruncatedNormal( + weightsShape, 0.0, Math.sqrt(this.scale / n)); + } else if (this.distribution === 'uniform') { + return NDArray.randUniform( + weightsShape, 0.0, Math.sqrt(3 * this.scale / n)); + } else { + throw new Error( + 'Unexpected distribution for variance scaling initializer: ' + + this.distribution); + } + } +} + +export class ZerosInitializer implements Initializer { + constructor() {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + return NDArray.zeros(weightsShape); + } +} + +export class OnesInitializer implements Initializer { + constructor() {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + const values = NDArray.zeros(weightsShape); + values.fill(1); + return values; + } +} + +export class ConstantInitializer implements Initializer { + constructor(private value = 0) {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + const values = NDArray.zeros(weightsShape); + values.fill(this.value); + return values; + } +} + +export class NDArrayInitializer implements Initializer { + constructor(private ndarray: NDArray) {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + return this.ndarray; + } +} + +export class RandomNormalInitializer implements Initializer { + constructor(private mean = 0, private stdev = .05) {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + return NDArray.randNormal(weightsShape, this.mean, this.stdev); + } +} + +export class RandomTruncatedNormalInitializer implements Initializer { + constructor(private mean = 0, private stdev = .05) {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + return NDArray.randTruncatedNormal(weightsShape, this.mean, this.stdev); + } +} + +export class RandomUniformInitializer implements Initializer { + constructor(private minval = -.05, private maxval = .05) {} + + initialize(weightsShape: number[], inputUnits: number, outputUnits: number): + NDArray { + return NDArray.randUniform(weightsShape, this.minval, this.maxval); + } +} diff --git a/src/input_provider.ts b/src/input_provider.ts new file mode 100644 index 0000000000..e62027ba56 --- /dev/null +++ b/src/input_provider.ts @@ -0,0 +1,169 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMath} from './math/math'; +import {NDArray} from './math/ndarray'; +import * as util from './util'; + +/** + * The interface for input providers. + */ +export interface InputProvider { + /** + * Get the next input as a copy. This is important because the data might + * get uploaded to the GPU and modify the original data. + * @param math NDArrayMath + */ + getNextCopy(math: NDArrayMath): NDArray; + /** + * Dispose the input copy. + * @param math NDArrayMath + * @param copy The copy provided from getNextCopy + */ + disposeCopy(math: NDArrayMath, copy: NDArray): void; +} + +/** + * A common interface for shuffled input provider builders. This returns + * InputProviders that are synchronized. + * @hidden + */ +export interface ShuffledInputProviderBuilder { + getInputProviders(): InputProvider[]; +} + +/** + * @hidden + */ +export abstract class InMemoryShuffledInputProviderBuilder implements + ShuffledInputProviderBuilder { + protected shuffledIndices: Uint32Array; + protected numInputs: number; + + protected idx = 0; + // Counter for how many times the current index has been called. Resets to 0 + // when it reaches the number of inputs. + protected inputCounter = 0; + protected epoch = 0; + + /** + * Constructs an `InMemoryShuffledInputProvider`. All of the inputs must be + * in memory. + * @param inputs All of the inputs, size: [number of inputs][number of + * examples]. + */ + constructor(protected inputs: NDArray[][]) { + this.shuffledIndices = util.createShuffledIndices(inputs[0].length); + this.numInputs = inputs.length; + + // Make sure the number of examples in each input matches. + const numExamples = this.inputs[0].length; + for (let i = 0; i < this.numInputs; i++) { + util.assert( + this.inputs[i].length === numExamples, + 'Number of examples must match across different inputs.'); + } + + // Make sure the shapes within inputs all match. + for (let i = 0; i < this.numInputs; i++) { + const inputShape = this.inputs[i][0].shape; + for (let j = 0; j < this.inputs[i].length; j++) { + util.assertShapesMatch(inputShape, this.inputs[i][j].shape); + } + } + } + + protected getCurrentExampleIndex(): number { + const returnIdx = this.idx; + + this.inputCounter++; + if (this.inputCounter >= this.numInputs) { + this.idx++; + this.inputCounter = 0; + + if (this.idx >= this.inputs[0].length) { + this.idx = 0; + this.epoch++; + } + } + return returnIdx; + } + + protected getNextInput(inputId: number): NDArray { + const currentExampleIndex = this.getCurrentExampleIndex(); + + return this.inputs[inputId][this.shuffledIndices[currentExampleIndex]]; + } + + getEpoch() { + return this.epoch; + } + + /** + * Returns input providers which shuffle the inputs and stay in sync. + */ + getInputProviders(): InputProvider[] { + const inputProviders: InputProvider[] = []; + + for (let i = 0; i < this.numInputs; i++) { + inputProviders.push(this.getInputProvider(i)); + } + return inputProviders; + } + + abstract getInputProvider(inputId: number): InputProvider; +} + +/** + * An in CPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the + * CPU and keeps them mutually in sync. + */ +export class InCPUMemoryShuffledInputProviderBuilder extends + InMemoryShuffledInputProviderBuilder { + getInputProvider(inputId: number) { + const shuffledInputProvider = this; + + return { + getNextCopy(math: NDArrayMath): NDArray { + return NDArray.like(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy(math: NDArrayMath, copy: NDArray) { + copy.dispose(); + } + }; + } +} + +/** + * An in GPU memory ShuffledInputProviderBuilder that shuffles NDArrays on the + * GPU and keeps them mutually in sync. This is more performant than the CPU + * version as textures will stay in memory, however this is more GPU memory + * intensive as it keeps textures resident in GPU memory. + */ +export class InGPUMemoryShuffledInputProviderBuilder extends + InMemoryShuffledInputProviderBuilder { + getInputProvider(inputId: number) { + const shuffledInputProvider = this; + + return { + getNextCopy(math: NDArrayMath): NDArray { + return math.clone(shuffledInputProvider.getNextInput(inputId)); + }, + disposeCopy(math: NDArrayMath, copy: NDArray) { + copy.dispose(); + } + }; + } +} diff --git a/src/input_provider_test.ts b/src/input_provider_test.ts new file mode 100644 index 0000000000..0204926567 --- /dev/null +++ b/src/input_provider_test.ts @@ -0,0 +1,140 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {InCPUMemoryShuffledInputProviderBuilder} from './input_provider'; +import {NDArrayMathCPU} from './math/math_cpu'; +import {NDArrayMathGPU} from './math/math_gpu'; +import * as ndarray from './math/ndarray'; +import {Array1D, Scalar} from './math/ndarray'; + + +describe('InCPUMemoryShuffledInputProviderBuilder', () => { + let math: NDArrayMathCPU; + + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('ensure inputs stay in sync', () => { + const x1s = [Scalar.new(1), Scalar.new(2), Scalar.new(3)]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + const shuffledInputProvider = + new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s]); + + const [x1provider, x2provider] = shuffledInputProvider.getInputProviders(); + + const seenNumbers: {[key: number]: boolean} = {}; + for (let i = 0; i < x1s.length; i++) { + const x1 = x1provider.getNextCopy(math); + const x2 = x2provider.getNextCopy(math); + + expect(x1.get() * 10).toEqual(x2.get()); + + seenNumbers[x1.get()] = true; + seenNumbers[x2.get()] = true; + } + + // Values are shuffled, make sure we've seen everything. + const expectedSeenNumbers = [1, 2, 3, 10, 20, 30]; + for (let i = 0; i < expectedSeenNumbers.length; i++) { + expect(seenNumbers[expectedSeenNumbers[i]]).toEqual(true); + } + }); + + it('different number of examples', () => { + const x1s = [Scalar.new(1), Scalar.new(2)]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + expect(() => new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s])) + .toThrowError(); + }); + + it('different shapes within input', () => { + const x1s = [Scalar.new(1), Array1D.new([1, 2])]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + expect(() => new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s])) + .toThrowError(); + }); +}); + +describe('InGPUMemoryShuffledInputProviderBuilder', () => { + let math: NDArrayMathGPU; + + beforeEach(() => { + math = new NDArrayMathGPU(); + }); + + it('ensure inputs stay in sync', () => { + const x1s = [Scalar.new(1), Scalar.new(2), Scalar.new(3)]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + const shuffledInputProvider = + new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s]); + + const [x1provider, x2provider] = shuffledInputProvider.getInputProviders(); + + const seenNumbers: {[key: number]: boolean} = {}; + for (let i = 0; i < x1s.length; i++) { + const x1 = x1provider.getNextCopy(math); + const x2 = x2provider.getNextCopy(math); + + expect(x1.get() * 10).toEqual(x2.get()); + + seenNumbers[x1.get()] = true; + seenNumbers[x2.get()] = true; + + x1provider.disposeCopy(math, x1); + x2provider.disposeCopy(math, x1); + } + + // Values are shuffled, make sure we've seen everything. + const expectedSeenNumbers = [1, 2, 3, 10, 20, 30]; + for (let i = 0; i < expectedSeenNumbers.length; i++) { + expect(seenNumbers[expectedSeenNumbers[i]]).toEqual(true); + } + }); + + it('different number of examples', () => { + const x1s = [Scalar.new(1), Scalar.new(2)]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + expect(() => new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s])) + .toThrowError(); + + x1s.forEach(x1 => { + x1.dispose(); + }); + x2s.forEach(x2 => { + x2.dispose(); + }); + }); + + it('different shapes within input', () => { + const x1s = [Scalar.new(1), Array1D.new([1, 2])]; + const x2s = [Scalar.new(10), Scalar.new(20), Scalar.new(30)]; + + expect(() => new InCPUMemoryShuffledInputProviderBuilder([x1s, x2s])) + .toThrowError(); + + x1s.forEach(x1 => { + x1.dispose(); + }); + x2s.forEach(x2 => { + x2.dispose(); + }); + }); +}); \ No newline at end of file diff --git a/src/math/activation_functions.ts b/src/math/activation_functions.ts new file mode 100644 index 0000000000..0c357f2372 --- /dev/null +++ b/src/math/activation_functions.ts @@ -0,0 +1,84 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMath} from './math'; +import {NDArray, Scalar} from './ndarray'; + +/** A node's activation function and its derivative. */ +export interface ActivationFunction { + output(math: NDArrayMath, input: T): T; + der(math: NDArrayMath, input: T, output: T): T; +} + +export class TanHFunc implements ActivationFunction { + output(math: NDArrayMath, x: NDArray) { + return math.scope(() => { + return math.tanh(x); + }); + } + + der(math: NDArrayMath, x: NDArray, y: NDArray) { + return math.scope(() => { + const ySquared = math.elementWiseMul(y, y); + // 1 - y^2. + return math.scalarMinusArray(Scalar.ONE, ySquared); + }); + } +} + +export class ReLUFunc implements ActivationFunction { + output(math: NDArrayMath, x: NDArray) { + return math.scope(() => { + return math.relu(x); + }); + } + + der(math: NDArrayMath, x: NDArray, y: NDArray) { + return math.scope(() => { + return math.step(x); + }); + } +} + +export class SigmoidFunc implements ActivationFunction { + output(math: NDArrayMath, x: NDArray) { + return math.scope(() => { + return math.sigmoid(x); + }); + } + + der(math: NDArrayMath, x: NDArray, y: NDArray) { + return math.scope(() => { + // y * (1 - y) = y - y^2 + const ySquared = math.elementWiseMul(y, y); + return math.sub(y, ySquared); + }); + } +} + +export class SquareFunc implements ActivationFunction { + output(math: NDArrayMath, x: NDArray) { + return math.scope(() => { + return math.elementWiseMul(x, x); + }); + } + + der(math: NDArrayMath, x: NDArray, y: NDArray) { + return math.scope(() => { + // dy/dx = 2*x. + return math.scalarTimesArray(Scalar.TWO, x); + }); + } +} diff --git a/src/math/activation_functions_test.ts b/src/math/activation_functions_test.ts new file mode 100644 index 0000000000..cd98828d0a --- /dev/null +++ b/src/math/activation_functions_test.ts @@ -0,0 +1,97 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; + +import {ReLUFunc, SigmoidFunc, TanHFunc} from './activation_functions'; +import {NDArrayMathCPU} from './math_cpu'; +import {Array1D} from './ndarray'; + +describe('Activation functions', () => { + let math: NDArrayMathCPU; + + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('Tanh output', () => { + const x = Array1D.new([1, 3, -2, 100, -100, 0]); + const tanH = new TanHFunc(); + const y = tanH.output(math, x); + + expect(y.get(0)).toBeCloseTo(util.tanh(x.get(0))); + expect(y.get(1)).toBeCloseTo(util.tanh(x.get(1))); + expect(y.get(2)).toBeCloseTo(util.tanh(x.get(2))); + expect(y.get(3)).toBeCloseTo(1); + expect(y.get(4)).toBeCloseTo(-1); + expect(y.get(5)).toBeCloseTo(0); + }); + + it('Tanh derivative', () => { + const x = Array1D.new([1, 3, -2, 100, -100, 0]); + const tanH = new TanHFunc(); + const y = tanH.output(math, x); + const dx = tanH.der(math, x, y); + + expect(dx.get(0)).toBeCloseTo(1 - Math.pow(y.get(0), 2)); + expect(dx.get(1)).toBeCloseTo(1 - Math.pow(y.get(1), 2)); + expect(dx.get(2)).toBeCloseTo(1 - Math.pow(y.get(2), 2)); + }); + + it('ReLU output', () => { + const x = Array1D.new([1, 3, -2]); + const relu = new ReLUFunc(); + const y = relu.output(math, x); + + expect(y.get(0)).toBeCloseTo(1); + expect(y.get(1)).toBeCloseTo(3); + expect(y.get(2)).toBeCloseTo(0); + }); + + it('ReLU derivative', () => { + const x = Array1D.new([1, 3, -2]); + const relu = new ReLUFunc(); + const y = relu.output(math, x); + const dx = relu.der(math, x, y); + + expect(dx.get(0)).toBeCloseTo(1); + expect(dx.get(1)).toBeCloseTo(1); + expect(dx.get(2)).toBeCloseTo(0); + }); + + it('Sigmoid output', () => { + const x = Array1D.new([1, 3, -2, 100, -100, 0]); + const sigmoid = new SigmoidFunc(); + const y = sigmoid.output(math, x); + + expect(y.get(0)).toBeCloseTo(1 / (1 + Math.exp(-1))); + expect(y.get(1)).toBeCloseTo(1 / (1 + Math.exp(-3))); + expect(y.get(2)).toBeCloseTo(1 / (1 + Math.exp(2))); + expect(y.get(3)).toBeCloseTo(1); + expect(y.get(4)).toBeCloseTo(0); + expect(y.get(5)).toBeCloseTo(0.5); + }); + + it('Sigmoid derivative', () => { + const x = Array1D.new([1, 3, -2, 100, -100, 0]); + const sigmoid = new SigmoidFunc(); + const y = sigmoid.output(math, x); + const dx = sigmoid.der(math, x, y); + + expect(dx.get(0)).toBeCloseTo(y.get(0) * (1 - y.get(0))); + expect(dx.get(1)).toBeCloseTo(y.get(1) * (1 - y.get(1))); + expect(dx.get(2)).toBeCloseTo(y.get(2) * (1 - y.get(2))); + }); +}); diff --git a/src/math/concat3d_util.ts b/src/math/concat3d_util.ts new file mode 100644 index 0000000000..2f5fda3aec --- /dev/null +++ b/src/math/concat3d_util.ts @@ -0,0 +1,49 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; + +export function assertConcat3DShapesMatch( + x1Shape: number[], x2Shape: number[], axis: number, + errorMessagePrefix = '') { + util.assert( + x1Shape.length === 3, + errorMessagePrefix + 'Concat3D x1 shape should be of rank 3.'); + util.assert( + x2Shape.length === 3, + errorMessagePrefix + 'Concat3D x2 shape should be of rank 3.'); + + util.assert( + axis >= 0 && axis < 3, 'Axis for concat3D must be between 0 and 2.'); + + for (let i = 0; i < 3; i++) { + util.assert( + (i === axis) || (x1Shape[i] === x2Shape[i]), + errorMessagePrefix + + `Shape (${x1Shape}) does not match (${x2Shape}) along ` + + `non-concatenated axis.`); + } +} + +export function computeConcat3DOutputShape( + x1Shape: number[], x2Shape: number[], + axis: number): [number, number, number] { + util.assert(x1Shape.length === 3, 'Concat3D x1 shape should be of rank 3.'); + util.assert(x2Shape.length === 3, 'Concat3D x2shape should be of rank 3.'); + + const outputShape = x1Shape.slice(); + outputShape[axis] += x2Shape[axis]; + return outputShape as [number, number, number]; +} \ No newline at end of file diff --git a/src/math/concat3d_util_test.ts b/src/math/concat3d_util_test.ts new file mode 100644 index 0000000000..9f72e8a4c9 --- /dev/null +++ b/src/math/concat3d_util_test.ts @@ -0,0 +1,66 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../test_util'; +import * as concat3d_util from './concat3d_util'; + +describe('concat3d_util.assertConcat3DShapesMatch', () => { + it('Non-3D tensor x1', () => { + const assertFn = () => { + concat3d_util.assertConcat3DShapesMatch([1], [1, 2, 3], 1); + }; + + expect(assertFn).toThrow(); + }); + + it('Non-3D tensor x2', () => { + const assertFn = () => { + concat3d_util.assertConcat3DShapesMatch([1, 2, 3], [2, 3], 1); + }; + + expect(assertFn).toThrow(); + }); + + it('axis out of bound', () => { + const assertFn = () => { + concat3d_util.assertConcat3DShapesMatch([1, 2, 3], [1, 2, 3], 4); + }; + + expect(assertFn).toThrow(); + }); + + it('non-axis shape mismatch', () => { + const assertFn = () => { + concat3d_util.assertConcat3DShapesMatch([2, 3, 3], [2, 2, 4], 2); + }; + + expect(assertFn).toThrow(); + }); + + it('shapes line up', () => { + const assertFn = () => { + concat3d_util.assertConcat3DShapesMatch([2, 3, 3], [2, 3, 4], 2); + }; + + expect(assertFn).not.toThrow(); + }); +}); + +describe('concat3d_util.computeConcat3DOutputShape', () => { + it('compute output shape, axis=0', () => { + expect(concat3d_util.computeConcat3DOutputShape([2, 2, 3], [1, 2, 3], 0)) + .toEqual([3, 2, 3]); + }); +}); \ No newline at end of file diff --git a/src/math/conv_util.ts b/src/math/conv_util.ts new file mode 100644 index 0000000000..36d8455cda --- /dev/null +++ b/src/math/conv_util.ts @@ -0,0 +1,73 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; + +export function computeOutputShape3D( + inputShapeRowColDepth: [number, number, number], fieldSize: number, + depth: number, stride: number, zeroPad?: number): [number, number, number] { + if (zeroPad == null) { + zeroPad = computeDefaultPad(inputShapeRowColDepth, fieldSize, stride); + } + const inputRows = inputShapeRowColDepth[0]; + const inputCols = inputShapeRowColDepth[1]; + const outputRows = (inputRows - fieldSize + 2 * zeroPad) / stride + 1; + util.assert( + util.isInt(outputRows), + `The output # of rows (${outputRows}) must be an integer. Change the ` + + `stride and/or zero pad parameters`); + + const outputCols = (inputCols - fieldSize + 2 * zeroPad) / stride + 1; + util.assert( + util.isInt(outputCols), + `The output # of columns (${outputCols}) must be an integer. Change ` + + `the stride and/or zero pad parameters`); + + return [outputRows, outputCols, depth]; +} + +export function computeDefaultPad( + inputShape: [number, number, number], fieldSize: number, + stride: number): number { + return Math.floor((inputShape[0] * (stride - 1) - stride + fieldSize) / 2); +} + +export function computeTexShapeFrom3D( + shapeRowColDepth: [number, number, number]): [number, number] { + return [shapeRowColDepth[0], shapeRowColDepth[1] * shapeRowColDepth[2]]; +} + +export function computeWeightsShape4D( + inputDepth: number, outputDepth: number, + fSize: number): [number, number, number, number] { + return [fSize, fSize, inputDepth, outputDepth]; +} + +export function computeWeightsTexShape( + inputDepth: number, outputDepth: number, + fieldSize: number): [number, number] { + return [fieldSize * fieldSize * inputDepth, outputDepth]; +} + +export function computeBiasesTexShape(outputDepth: number): [number, number] { + return [1, outputDepth]; +} + +export function computeDilatedRC( + rc: [number, number], origStride: number): [number, number] { + const rowsDilated = (rc[0] - 1) * origStride + 1; + const colsDilated = (rc[1] - 1) * origStride + 1; + return [rowsDilated, colsDilated]; +} diff --git a/src/math/copy2d_util.ts b/src/math/copy2d_util.ts new file mode 100644 index 0000000000..6b2f6e750e --- /dev/null +++ b/src/math/copy2d_util.ts @@ -0,0 +1,27 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export function validateShapes( + sourceSize: [number, number], destSize: [number, number]) { + const srcArea = sourceSize[0] * sourceSize[1]; + const dstArea = destSize[0] * destSize[1]; + if (srcArea !== dstArea) { + const srcStr = '[' + sourceSize[0] + ', ' + sourceSize[1] + ']'; + const dstStr = '[' + destSize[0] + ', ' + destSize[1] + ']'; + throw new Error( + 'copy2D shapes have different areas:\n sourceSize ' + srcStr + + ', area ' + srcArea + '\n destSize ' + dstStr + ', area ' + dstArea); + } +} diff --git a/src/math/cost_functions.ts b/src/math/cost_functions.ts new file mode 100644 index 0000000000..44590a0878 --- /dev/null +++ b/src/math/cost_functions.ts @@ -0,0 +1,49 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMath} from './math'; +import {NDArray, Scalar} from './ndarray'; + +/** + * An error function and its derivative. + */ +export interface ElementWiseCostFunction { + cost(math: NDArrayMath, x1: T, x2: T): T; + der(math: NDArrayMath, x1: T, x2: T): T; + dispose(): void; +} + +export class SquareCostFunc implements ElementWiseCostFunction { + private halfOne = Scalar.new(0.5); + + cost(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray { + const diff = math.sub(x1, x2); + const diffSquared = math.elementWiseMul(diff, diff); + const result = math.scalarTimesArray(this.halfOne, diffSquared); + + diff.dispose(); + diffSquared.dispose(); + + return result; + } + + der(math: NDArrayMath, x1: NDArray, x2: NDArray): NDArray { + return math.sub(x1, x2); + } + + dispose() { + this.halfOne.dispose(); + } +} diff --git a/src/math/cost_functions_test.ts b/src/math/cost_functions_test.ts new file mode 100644 index 0000000000..32409af90e --- /dev/null +++ b/src/math/cost_functions_test.ts @@ -0,0 +1,49 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {SquareCostFunc} from './cost_functions'; +import {NDArrayMathCPU} from './math_cpu'; +import {Array1D} from './ndarray'; + +describe('Cost functions', () => { + let math: NDArrayMathCPU; + + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('Square cost', () => { + const y = Array1D.new([1, 3, -2]); + const target = Array1D.new([0, 3, -1.5]); + const square = new SquareCostFunc(); + const cost = square.cost(math, y, target); + + // The cost function is 1/2 * (y - target)^2 + expect(cost.get(0)).toBeCloseTo(1 / 2); + expect(cost.get(1)).toBeCloseTo(0 / 2); + expect(cost.get(2)).toBeCloseTo(0.25 / 2); + }); + + it('Square derivative', () => { + const y = Array1D.new([1, 3, -2]); + const target = Array1D.new([0, 3, -1.5]); + const square = new SquareCostFunc(); + const dy = square.der(math, y, target); + + expect(dy.get(0)).toBeCloseTo(1); + expect(dy.get(1)).toBeCloseTo(0); + expect(dy.get(2)).toBeCloseTo(-0.5); + }); +}); // Close describe. diff --git a/src/math/math.ts b/src/math/math.ts new file mode 100644 index 0000000000..2c445c2549 --- /dev/null +++ b/src/math/math.ts @@ -0,0 +1,1065 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; +import * as concat3d_util from './concat3d_util'; +import * as copy2d_util from './copy2d_util'; + +import {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray'; + +export type ScopeResult = NDArray[]|NDArray|void; + +export abstract class NDArrayMath { + private ndarrayScopes: NDArray[][] = []; + private activeScope: NDArray[]; + + private ndarraysToKeep: NDArray[][] = []; + private activeScopeNDArraysToKeep: NDArray[] = []; + + /** + * @param safeMode In safe mode, you must use math operations inside + * a math.scope() which will automatically clean up intermediate NDArrays. + */ + constructor(private safeMode: boolean) {} + + /** + * Create a new math scope. Put chained math operations inside a scope + * function closure so that the library automatically cleans up NDArrays + * from intermediate math operations. You must create a scope in safe mode + * to call math operations. If a result is returned from the scope, it will + * also be tracked, which means there must be yet another wrapping scope. + * @param scopeFn The function to execute with chained math operations. + */ + scope( + scopeFn: + (keep: (ndarray: T1) => T1, + track: (ndarray: T2) => T2) => T) { + this.startScope(); + + const keepFn = (ndarray: T): T => this.keep(ndarray); + const trackFn = (ndarray: T): T => this.track(ndarray); + const result = scopeFn(keepFn, trackFn); + + this.endScope(result); + + return result; + } + + /** + * Start a scope. Use this with endScope() to achieve the same functionality + * as scope() without the need for a function closure. + */ + startScope() { + const newScope: NDArray[] = []; + this.ndarrayScopes.push(newScope); + this.activeScope = newScope; + + const newNDArraysToKeep: NDArray[] = []; + this.ndarraysToKeep.push(newNDArraysToKeep); + this.activeScopeNDArraysToKeep = newNDArraysToKeep; + } + + /** + * End a scope. Use this with startScope() to achieve the same functionality + * as scope() without the need for a function closure. + */ + endScope(result: ScopeResult) { + // Dispose the current scope. + for (let i = 0; i < this.activeScope.length; i++) { + const ndarray = this.activeScope[i]; + + if (this.isNDArrayDataInList(ndarray, this.activeScopeNDArraysToKeep) || + (result != null && result instanceof NDArray && + ndarray.getData() === (result as NDArray).getData())) { + continue; + } + ndarray.dispose(); + } + + // Pop the current scope. + this.ndarrayScopes.pop(); + this.activeScope = this.ndarrayScopes.length === 0 ? + null! : + this.ndarrayScopes[this.ndarrayScopes.length - 1]; + + // Track the current result in the parent scope. + if (result instanceof NDArray && + !this.isNDArrayDataInList(result, this.activeScopeNDArraysToKeep)) { + this.track(result); + } else if (Array.isArray(result)) { + result.forEach(r => { + if (r instanceof NDArray && + !this.isNDArrayDataInList(r, this.activeScopeNDArraysToKeep)) { + this.track(r); + } + }); + } + + this.ndarraysToKeep.pop(); + this.activeScopeNDArraysToKeep = this.ndarraysToKeep.length === 0 ? + null! : + this.ndarraysToKeep[this.ndarraysToKeep.length - 1]; + } + + private isNDArrayDataInList(ndarray: NDArray, ndarrayList: NDArray[]) { + for (let i = 0; i < ndarrayList.length; i++) { + if (ndarrayList[i].getData() === ndarray.getData()) { + return true; + } + } + return false; + } + + /** + * Keeps an NDArray in the current scope from being disposed automatically. + * @param result The NDArray to keep from being disposed. + */ + keep(result: T): T { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error( + 'You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScopeNDArraysToKeep.push(result); + return result; + } + + /** + * Tracks an NDArray in the current scope to be automatically cleaned up when + * the current scope ends, and returns the value. + * @param result The NDArray to track in the current scope. + */ + track(result: T): T { + if (this.activeScope == null) { + if (this.safeMode) { + throw new Error( + 'You are using math in safe mode. Enclose all ' + + 'math.method() calls inside a scope: ' + + 'math.scope(() => {math.method();...}) to avoid memory ' + + 'leaks.'); + } + return result; + } + this.activeScope.push(result); + return result; + } + + /** + * Computes the dot product of two matrices, A * B. These must be matrices, + * use matrixTimesVector and vectorTimesMatrix, dotProduct, and outerProduct + * in other cases. + * @param a First matrix in dot product operation. + * @param b Second matrix in dot product operation. + * @param aOrientation The MatrixOrientation of A. If using TRANSPOSED, will + * compute A^T * B. + * @param bOrientation The MatrixOrientation of B. If using TRANSPOSED, will + * compute A * B^T. + */ + matMul( + a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Array2D { + const innerShapeA = + (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + const innerShapeB = + (bOrientation === MatrixOrientation.REGULAR) ? b.shape[0] : b.shape[1]; + + util.assert( + a.rank === 2 && b.rank === 2, + `Error in matMul: inputs must be rank 2, got ranks ${a.rank}` + + `and ${b.rank}.`); + + util.assert( + innerShapeA === innerShapeB, + `Error in matMul: inner shapes (${innerShapeA}) and (` + + `${innerShapeB}) of NDArrays with shapes ${a.shape} and ` + + `${b.shape} and orientations ${MatrixOrientation[aOrientation]}` + + ` and ${MatrixOrientation[bOrientation]} must match.`); + + return this.track(this.matMulInternal(a, b, aOrientation, bOrientation)); + } + protected abstract matMulInternal( + a: Array2D, b: Array2D, aOrientation: MatrixOrientation, + bOrientation: MatrixOrientation): Array2D; + + /** + * Computes the dot product of a vector and a matrix, v * B. + * @param v The vector in dot product operation. + * @param matrix The matrix in dot product operation. + */ + vectorTimesMatrix(v: Array1D, matrix: Array2D): Array1D { + util.assert( + v.rank === 1, + `Error in vectorTimesMatrix: first input must be rank 1, but got ` + + `rank ${v.rank}.`); + util.assert( + matrix.rank === 2, + `Error in vectorTimesMatrix: second input must be rank 2, but got ` + + `rank ${matrix.rank}.`); + util.assert( + v.size === matrix.shape[0], + `Error in vectorTimesMatrix: size of first rank 1 input (${v.size}) ` + + `must match inner dimension of second rank 2 input, but got ` + + `rank ${matrix.rank}.`); + + return this.matMul(v.as2D(1, v.size), matrix).as1D(); + } + + /** + * Computes the dot product of a matrix and vector, A * v. + * @param matrix The matrix in dot product operation. + * @param v The vector in dot product operation. + */ + matrixTimesVector(matrix: Array2D, v: Array1D): Array1D { + util.assert( + v.rank === 1, + `Error in vectorTimesMatrix: second input must rank 1, but got ` + + `rank ${v.rank}.`); + util.assert( + matrix.rank === 2, + `Error in vectorTimesMatrix: first input must be a rank 2, but got ` + + `rank ${matrix.rank}.`); + util.assert( + v.size === matrix.shape[1], + `Error in vectorTimesMatrix: size of first rank 1 input ${v.size} ` + + `must match inner dimension of second rank 2 input, but got ` + + `shape ${matrix.shape}.`); + + return this.matMul(matrix, v.as2D(v.size, 1)).as1D(); + } + + /** + * Computes the dot product of two vectors, v1 * v2. + * @param v1 The first vector in the dot product operation. + * @param v2 The second vector in the dot product operation. + */ + dotProduct(v1: Array1D, v2: Array1D): Scalar { + util.assert( + v1.rank === 1 && v2.rank === 1, + `Error in dotProduct: inputs must be rank 1, but got ranks ` + + `${v1.rank} and ${v2.rank}.`); + util.assert( + v1.size === v2.size, + `Error in dotProduct: size of inputs (${v1.size}) and (` + + `${v2.size}) must match.`); + return this.matMul(v1.as2D(1, v1.size), v2.as2D(v2.size, 1)).asScalar(); + } + + /** + * Computes the outer product of two vectors, v1 and v2. + * @param v1 The first vector in the outer product operation. + * @param v2 The second vector in the dot product operation. + */ + outerProduct(v1: Array1D, v2: Array1D): Array2D { + util.assert( + v1.rank === 1 && v2.rank === 1, + `Error in outerProduct: inputs must be rank 1, but got ranks ` + + `${v1.rank} and ${v2.rank}.`); + + return this.matMul(v1.as2D(v1.size, 1), v2.as2D(1, v2.size)); + } + + /////////////// + // Shape ops // + /////////////// + + /** + * Clones an NDArray of any shape. + * @param ndarray The NDArray to clone. + */ + clone(ndarray: T): T { + return this.track(this.cloneInternal(ndarray)); + } + protected abstract cloneInternal(ndarray: T): T; + + /** + * Reshapes an NDArray to a new shape. The size of the input NDArray must + * match the size of the requested shape. + * @param ndarray The input NDArray. + * @param newShape The new shape to reshape the NDArray to. Must be the same + * size as the NDArray. + */ + reshape( + ndarray: T1, newShape: number[]): T2 { + util.assert( + ndarray.size === util.sizeFromShape(newShape), + `Error in reshape: old size ${ndarray.size} must match new size ` + + `${util.sizeFromShape(newShape)}.`); + return this.track(this.reshapeInternal(ndarray, newShape)); + } + protected abstract reshapeInternal( + ndarray: T1, newShape: number[]): T2; + + /** + * Extracts a slice from a matrix. The operation extraces a slice from input + * that starts at coordinates `begin` and is of size `size`. + * @param input The input matrix to slice from. + * @param begin The 2D coordinates in the input matrix to start the slice + * from. + * @param size The sice of the 2D window to slice. + */ + slice2D(input: Array2D, begin: [number, number], size: [number, number]): + Array2D { + util.assert( + begin[0] + size[0] <= input.shape[0] && + begin[1] + size[1] <= input.shape[1], + `Error in slice2D: requested start position ${begin} and size ` + + `${size} would overflow input of shape ${input.shape}.`); + return this.track(this.slice2DInternal(input, begin, size)); + } + protected abstract slice2DInternal( + input: Array2D, begin: [number, number], size: [number, number]): Array2D; + + /** + * Copies a window from the `source` matrix starting at `sourceBegin` and is + * of size `sourceSize` to a window in the `dest` matrix starting at + * `destBegin` and is of size `destSize`/ + * @param source The source matrix to copy from. + * @param sourceBegin The coordinates to start the copy from. + * @param sourceSize The size of the copy window. + * @param dest The destination matrix to copy to. + * @param destBegin The coordinates in `dest` to copy to. + * @param destSize The size of the destination window. + */ + copy2D( + source: Array2D, sourceBegin: [number, number], + sourceSize: [number, number], dest: Array2D, destBegin: [number, number], + destSize: [number, number]) { + util.assert( + sourceBegin[0] + sourceSize[0] <= source.shape[0] && + sourceBegin[1] + sourceSize[1] <= source.shape[1], + `Error in copy2D: requested source start position ${sourceBegin} ` + + `and source size ${sourceSize} would overflow source NDArray` + + `of shape ${source.shape}.`); + util.assert( + destBegin[0] + destSize[0] <= dest.shape[0] && + destBegin[1] + destSize[1] <= dest.shape[1], + `Error in copy2D: requested dest start position ${destBegin} ` + + `and source size ${destSize} would overflow dest NDArray of` + + `shape ${dest.shape}.`); + copy2d_util.validateShapes(sourceSize, destSize); + + return this.copy2DInternal( + source, sourceBegin, sourceSize, dest, destBegin, destSize); + } + protected abstract copy2DInternal( + source: Array2D, sourceBegin: [number, number], + sourceSize: [number, number], dest: Array2D, destBegin: [number, number], + destSize: [number, number]): void; + + /** + * Concatenates two 3D ndarrays along a given axis. + * + * For example, if: + * A: shape(2, 1, 3) = | r1, g1, b1 | + * | r2, g2, b2 | + * + * B: shape(2, 1, 3) = | r3, g3, b3 | + * | r4, g4, b4 | + * + * C = concat3D(A, B, axis) + * + * if axis = 0: + * C: shape(4, 1, 3) = | r1, g1, b1 | + * | r2, g2, b2 | + * | r3, g3, b3 | + * | r4, g4, b4 | + * + * if axis = 1: + * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 | + * | r2, g2, b2, r4, g4, b4 | + * + * if axis = 2: + * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 | + * | r2, g2, b2, r4, g4, b4 | + * + * @param ndarray1 The first array to concat. + * @param ndarray2 The second array to conat. + * @param axis The axis to concate along. + */ + concat3D(ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D { + concat3d_util.assertConcat3DShapesMatch( + ndarray1.shape, ndarray2.shape, axis, 'Error in concat3d: '); + return this.track(this.concat3DInternal(ndarray1, ndarray2, axis)); + } + protected abstract concat3DInternal( + ndarray1: Array3D, ndarray2: Array3D, axis: number): Array3D; + + /////////////////// + // Reduction ops // + /////////////////// + + /** + * Computes the the log(sum(e ^ x)) for each x in the input ndarray. + * @param ndarray The input NDArray to compute the logSumExp over. + */ + logSumExp(ndarray: NDArray): Scalar { + return this.track(this.logSumExpInternal(ndarray)); + } + protected abstract logSumExpInternal(ndarray: NDArray): Scalar; + + /** + * Computes the sum of all the entries in the input NDArray. + * @param ndarray The input NDArray to compute the sum over. + */ + sum(ndarray: NDArray): Scalar { + return this.track(this.sumInternal(ndarray)); + } + protected abstract sumInternal(ndarray: NDArray): Scalar; + + /** + * Computes the flattened index of the minimum element in the ndarray. + * @param ndarray The input NDArray. + */ + argMin(ndarray: NDArray): Scalar { + return this.track(this.argMinInternal(ndarray)); + } + protected abstract argMinInternal(ndarray: NDArray): Scalar; + + /** + * Computes the flattened index of the maximum element in the ndarray. + * @param ndarray The input NDArray. + */ + argMax(ndarray: NDArray): Scalar { + return this.track(this.argMaxInternal(ndarray)); + } + protected abstract argMaxInternal(ndarray: NDArray): Scalar; + + /** + * Returns a 1 if the argMax of x1 and x2 are the same, otherwise 0. + * @param x1 The first input NDArray. + * @param x2 The second input NDArray. + */ + argMaxEquals(x1: NDArray, x2: NDArray): Scalar { + util.assertShapesMatch(x1.shape, x2.shape, 'Error in argMaxEquals: '); + return this.track(this.argMaxEqualsInternal(x1, x2)); + } + protected abstract argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar; + + /** + * Computes the top K values and flattened indices. + * @param ndarray The input NDArray. + * @param k How many top values to compute. + */ + topK(ndarray: NDArray, k: number): {values: Array1D, indices: Array1D} { + util.assert( + k <= ndarray.size, + `Error in topK: k value (${k}) must be less than size of input ` + + `ndarray, got shape ${ndarray.shape}.`); + const result = this.topKInternal(ndarray, k); + this.track(result.values); + this.track(result.indices); + return result; + } + protected abstract topKInternal(ndarray: NDArray, k: number): + {values: Array1D, indices: Array1D}; + + /** + * Computes the minimum value from the input. + * @param ndarray The input NDArray. + */ + min(ndarray: NDArray): Scalar { + return this.track(this.minInternal(ndarray)); + } + protected abstract minInternal(ndarray: NDArray): Scalar; + + /** + * Computes the maximum value from the input. + * @param ndarray The input NDArray. + */ + max(ndarray: NDArray): Scalar { + return this.track(this.maxInternal(ndarray)); + } + protected abstract maxInternal(ndarray: NDArray): Scalar; + + /** + * Computes the softmax normalized vector from the input vector. + * @param x The input vector. + */ + softmax(x: Array1D): Array1D { + return this.scope(() => { + // Do it in log space for numerical stability. + // exp(X - logSumExp(X)) + const lse = this.logSumExp(x); + const logResult = this.arrayMinusScalar(x, lse); + return this.exp(logResult); + }); + } + + ////////////////////// + // Element-wise ops // + ////////////////////// + + /** + * Switches dimensions of the input NDArray. + * @param a The input NDArray. + * @param newDim The new indices that define which shapes values to switch. + */ + switchDim(a: T, newDim: number[]): T { + util.assert( + a.rank === newDim.length, + `Error in switchDim: length of input shape ${a.shape} ` + + `must match size of newDim array ${newDim}.`); + return this.track(this.switchDimInternal(a, newDim)); + } + protected abstract switchDimInternal( + a: T, newDim: number[]): T; + + /** + * Computes a scalar plus NDArray, c + A. + * @param c The scalar c in c + A. + * @param a The NDArray A in c + A. + */ + scalarPlusArray(c: Scalar, a: T): T { + util.assert( + c.size === 1, + `Error in scalarPlusArray: first argument must be rank 0, but got ` + + `rank ${c.rank}.`); + return this.track(this.scalarPlusArrayInternal(c, a)); + } + protected abstract scalarPlusArrayInternal( + c: Scalar, a: T): T; + + /** + * Computes a scalar minus NDArray, c - A. + * @param c The scalar c in c - A. + * @param a The NDArray A in c - A. + */ + scalarMinusArray(c: Scalar, a: T): T { + util.assert( + c.size === 1, + `Error in scalarMinusArray: first argument must be rank 0, but got ` + + `rank ${c.rank}.`); + return this.track(this.scalarMinusArrayInternal(c, a)); + } + protected abstract scalarMinusArrayInternal( + c: Scalar, a: T): T; + + /** + * Computes a scalar minus NDArray, A - c. + * @param a The NDArray A in A - c. + * @param c The scalar c in A - c. + */ + arrayMinusScalar(a: T, c: Scalar): T { + util.assert( + c.size === 1, + `Error in arrayMinusScalar: second argument must be rank 0, but ` + + `got rank ${c.rank}.`); + return this.track(this.arrayMinusScalarInternal(a, c)); + } + protected abstract arrayMinusScalarInternal( + a: T, c: Scalar): T; + + /** + * Computes -1 * A element-wise. + * @param a The input array. + */ + neg(a: T): T { + return this.track(this.negInternal(a)); + } + protected abstract negInternal(a: T): T; + + /** + * Adds two NDArrays element-wise, A + B. Inputs must be the same shape. + * @param a The first NDArray to add element-wise. + * @param b The second NDArray to add element-wise. + */ + add(a: T, b: T): T { + util.assertShapesMatch(a.shape, b.shape, 'Error in add: '); + return this.track(this.addInternal(a, b)); + } + protected abstract addInternal(a: T, b: T): T; + + /** + * Subtracts two NDArrays element-wise, A - B. Inputs must be the same shape. + * @param a The first NDArray to subtract element-wise. + * @param b The second NDArray to subtract element-wise. + */ + sub(a: T, b: T): T { + util.assertShapesMatch(a.shape, b.shape, 'Error in sub: '); + return this.track(this.subInternal(a, b)); + } + protected abstract subInternal(a: T, b: T): T; + + /** + * Multiplies two NDArrays element-wise (hadamard product), A * B. Inputs must + * be the same shape. + * @param a The first NDArray to multiply element-wise. + * @param b The second NDArray to multiply element-wise. + */ + elementWiseMul(a: T, b: T): T { + util.assertShapesMatch(a.shape, b.shape, 'Error in elementWiseMul: '); + return this.track(this.elementWiseMulInternal(a, b)); + } + protected abstract elementWiseMulInternal(a: T, b: T): T; + + /** + * Divides two NDArrays element-wise (hadamard product), A / B. Inputs must be + * the same shape. + * @param a The first NDArray to divide element-wise. + * @param b The second NDArray to divide element-wise. + */ + divide(a: T, b: T): T { + util.assertShapesMatch(a.shape, b.shape, 'Error in divide: '); + return this.track(this.divideInternal(a, b)); + } + protected abstract divideInternal(a: T, b: T): T; + + /** + * Computes a scalar divided by an NDArray, broadcasted over the NDArray, c / + * A. + * @param c The scalar value in c / A. + * @param a The NDArray value in c / A. + */ + scalarDividedByArray(c: Scalar, a: T): T { + util.assert( + c.size === 1, + `Error in scalarDividedByArray: first argument must be rank 0, but ` + + `got NDArray of rank ${c.rank}.`); + return this.track(this.scalarDividedByArrayInternal(c, a)); + } + protected abstract scalarDividedByArrayInternal( + c: Scalar, a: T): T; + + /** + * Computes an NDArray divided by a scalar, broadcasted over the NDArray, A / + * c. + * @param a The NDArray value in A / c. + * @param c The scalar value in A / c. + */ + arrayDividedByScalar(a: T, c: Scalar): T { + util.assert( + c.size === 1, + `Error in arrayDividedByScalar: second argument must be rank 0, ` + + `but got NDArray of rank ${c.rank}.`); + return this.track(this.arrayDividedByScalarInternal(a, c)); + } + protected abstract arrayDividedByScalarInternal( + a: T, c: Scalar): T; + + /** + * Computes exponential of the input NDArray element-wise. y = e ^ x + * @param ndarray The input NDArray. + */ + exp(ndarray: T): T { + return this.track(this.expInternal(ndarray)); + } + protected abstract expInternal(ndarray: T): T; + + /** + * Computes natural logarithm of the input NDArray element-wise. y = ln(x) + * @param ndarray The input NDArray. + */ + log(ndarray: T): T { + return this.track(this.logInternal(ndarray)); + } + protected abstract logInternal(ndarray: T): T; + + /** + * Computes rectified linear element-wise, max(x, 0). + * @param ndarray The input NDArray. + */ + relu(ndarray: T): T { + return this.track(this.reluInternal(ndarray)); + } + protected abstract reluInternal(ndarray: T): T; + + /** + * Computes sigmoid element-wise, y = 1 / (1 + exp(-x)). + * @param ndarray The input NDArray. + */ + sigmoid(ndarray: T): T { + return this.track(this.sigmoidInternal(ndarray)); + } + protected abstract sigmoidInternal(ndarray: T): T; + + /** + * Computes hyperbolic tangent of the input NDArray element-wise. + * @param ndarray The input NDArray. + */ + tanh(ndarray: T): T { + return this.track(this.tanhInternal(ndarray)); + } + protected abstract tanhInternal(ndarray: T): T; + + /** + * Computes sin of the input NDArray element-wise, y = sin(x). + * @param ndarray The input NDArray. + */ + sin(ndarray: T): T { + return this.track(this.sinInternal(ndarray)); + } + protected abstract sinInternal(ndarray: T): T; + + /** + * Computes step of the input NDArray element-wise, y = 1 if x > 0 | 0 if x <= + * 0 + * @param ndarray The input NDArray. + */ + step(ndarray: T): T { + return this.track(this.stepInternal(ndarray)); + } + protected abstract stepInternal(ndarray: T): T; + + /** + * Computes a scaled array add operation, c1 * A + c2 * B. + * @param c1 The first scalar in the scaled array add computation. + * @param a The first NDArray in the scaled array add computation. + * @param c2 The second scalar in the scaled array add computation. + * @param cb The second NDArray in the scaled array add computation. + */ + scaledArrayAdd(c1: Scalar, a: T, c2: Scalar, b: T): T { + util.assert( + c1.size === 1, + `Error in scaledArrayAdd: first argument must rank 0, but got ` + + ` rank ${c1.rank}.`); + util.assert( + c2.size === 1, + `Error in scaledArrayAdd: third argument must be rank 0, but got ` + + `NDArray of rank ${c2.rank}.`); + util.assertShapesMatch(a.shape, b.shape, 'Error in scaledArrayAdd: '); + + return this.track(this.scaledArrayAddInternal(c1, a, c2, b)); + } + protected abstract scaledArrayAddInternal( + c1: Scalar, a: T, c2: Scalar, b: T): T; + + /** + * Computes a scalar times array operation broadcasted over the NDArray, c * + * A. + * @param c The scalar in the operation. + * @param A the NDArray in the operation that will be broadcasted over. + */ + scalarTimesArray(c: Scalar, a: T): T { + util.assert( + c.size === 1, + `Error in arrayDividedByScalar: first argument must be rank 0, but ` + + `got rank ${c.rank}.`); + return this.track(this.scalarTimesArrayInternal(c, a)); + } + protected abstract scalarTimesArrayInternal( + c: Scalar, a: T): T; + + /** + * Computes an element-wise broadcasted multiplication of two matrices A and + * B. Will return a new matrix that is the max of A and B, where the smaller + * matrix will broadcast over the larger matrix. + * @param c The scalar in the operation. + * @param A the NDArray in the operation that will be broadcasted over. + */ + elementWiseMulBroadcast(a: Array2D, b: Array2D): Array2D { + util.assert( + a.rank === 2, + `Error in elementWiseMulBroadcast: first argument must be ` + + `rank 2, but got rank ${a.rank}.`); + util.assert( + b.rank === 2, + `Error in elementWiseMulBroadcast: second argument must be ` + + `rank 2, but got rank ${b.rank}.`); + return this.track(this.elementWiseMulBroadcastInternal(a, b)); + } + protected abstract elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): + Array2D; + + ///////////////////// + // Convolution ops // + ///////////////////// + + /** + * Computes a 2D convolution over the input x. + * @param x The input image, must be rank 3, of shape [rows, cols, depth1]. + * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1, + * depth2]. + * @param biases Optional biases NDArray, must be rank 1 of shape [depth2]. + * @param stride The stride of the convolution. + * @param zeroPad The zero padding of each side of the input NDArray. Will pad + * equally on all sides. + */ + conv2d( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + zeroPad: number): Array3D { + util.assert( + x.rank === 3, + `Error in conv2d: x must be rank 3, but got rank ${x.rank}.`); + util.assert( + weights.rank === 4, + `Error in conv2d: weights must be rank 4, but got rank ` + + `${weights.rank}.`); + if (biases != null) { + util.assert( + biases.rank === 1, + `Error in conv2d: biases must be rank 1, but got rank ` + + `${biases.rank}.`); + } + + util.assert( + x.shape[2] === weights.shape[2], + `Error in conv2d: depth of input (${x.shape[2]}) must match ` + + `input depth for weights ${weights.shape[2]}.`); + + + return this.track(this.conv2dInternal(x, weights, biases, stride, zeroPad)); + } + protected abstract conv2dInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + zeroPad: number): Array3D; + + /** + * Computes the backprop of a 2D convolution. + * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1]. + * @param dy The dy image, must be rank 3, of shape [yrows, ycols, depth2]. + * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1, + * depth2]. + * @param stride The stride of the original convolution. + * @param pad The padding of the original convolution. + */ + conv2dBackProp( + x: Array3D, dy: Array3D, weights: Array4D, stride: number, + pad: number): {dx: Array3D, dw: Array4D, db: Array1D} { + util.assert( + x.rank === 3, + `Error in conv2dBackProp: x must be rank 3, but got shape ` + + `${x.shape}.`); + util.assert( + dy.rank === 3, + `Error in conv2dBackProp: dy must be rank 3, but got shape ` + + `${dy.shape}.`); + util.assert( + weights.rank === 4, + `Error in conv2dBackProp: weights must be rank 4, but got shape ` + + `${weights.shape}.`); + util.assert( + x.shape[2] === weights.shape[2], + `Error in conv2dBackProp: depth of x ${x.shape[2]}) must ` + + `match input depth for weights (${weights.shape[2]}.`); + util.assert( + dy.shape[2] === weights.shape[3], + `Error in conv2dBackProp: depth of dy (${dy.shape[2]}) must ` + + `match output depth for weights (${weights.shape[3]}).`); + + const backpropResult = + this.conv2dBackPropInternal(x, dy, weights, stride, pad); + + this.track(backpropResult.db); + this.track(backpropResult.dw); + this.track(backpropResult.dx); + + return backpropResult; + } + protected abstract conv2dBackPropInternal( + x: Array3D, dy: Array3D, weights: Array4D, stride: number, + pad: number): {dx: Array3D, dw: Array4D, db: Array1D}; + + /** + * Computes the transposed 2D convolution of an image, also known as a + * deconvolution. + * @param x The input image, must be rank 3, of shape [xrows, xcols, depth1]. + * @param weights The weights NDArray, must be rank 4, of shape [f, f, depth1, + * depth2]. + * @param biases Optional biases NDArray, must be rank 1 of shape [depth2]. + * @param stride The stride of the convolution. + * @param pad The padding of each side of the input NDArray. Will pad equally + * on all sides. + */ + conv2dTranspose( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + pad: number): Array3D { + util.assert( + x.rank === 3, + `Error in conv2dTranspose: x must be rank 3, but got rank ` + + `${x.rank}.`); + util.assert( + weights.rank === 4, + `Error in conv2dTranspose: weights must be rank 4, but got ` + + `rank ${weights.rank}`); + if (biases != null) { + util.assert( + biases.rank === 1, + `Error in conv2dTranspose: biases must be rank 1, but got ' + + 'rank ${biases.rank}.`); + } + util.assert( + x.shape[2] === weights.shape[3], + `Error in conv2dTranspose: depth of input (${x.shape[2]}) must ` + + `match input depth for weights ${weights.shape[3]}.`); + + return this.track( + this.conv2dTransposeInternal(x, weights, biases, stride, pad)); + } + protected abstract conv2dTransposeInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + pad: number): Array3D; + + /** + * Computes the 2D max pooling of an image. + * @param x The input image, must be rank 3. + * @param fSize The field size of the max pool. + * @param stride The stride of the max pool. + * @param pad The padding of each side of the input NDArray. Will pad equally + * on all sides. + */ + maxPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D { + util.assert( + x.rank === 3, + 'Error in maxPool: x must be rank 3 but got rank ' + x.rank + '.'); + return this.track(this.maxPoolInternal(x, fSize, stride, pad)); + } + protected abstract maxPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D; + + /** + * Computes the backprop of a max pool. + * @param dy The dy error. + * @param x The input image, must be rank 3. + * @param fSize The field size of the max pool. + * @param stride The stride of the max pool. + * @param pad The padding of each side of the input NDArray. Will pad equally + * on all sides. + */ + maxPoolBackprop( + dy: Array3D, x: Array3D, fSize: number, stride: number, + pad: number): Array3D { + util.assert( + dy.rank === 3, + `Error in maxPoolBackprop: dy must be rank 3 but got rank ` + + `${dy.rank}.`); + util.assert( + x.rank === 3, + `Error in maxPoolBackprop: x must be rank 3 but got rank ` + + `${x.rank}.`); + + return this.track(this.maxPoolBackpropInternal(dy, x, fSize, stride, pad)); + } + protected abstract maxPoolBackpropInternal( + dy: Array3D, x: Array3D, fSize: number, stride: number, + pad: number): Array3D; + + /** + * Computes the 2D min pooling of an image. + * @param x The input image, must be rank 3. + * @param fSize The field size of the max pool. + * @param stride The stride of the max pool. + * @param pad The padding of each side of the input NDArray. Will pad equally + * on all sides. + */ + minPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D { + util.assert( + x.rank === 3, + `Error in minPool: x must be rank 3 but got rank ${x.rank}.`); + return this.track(this.minPoolInternal(x, fSize, stride, pad)); + } + protected abstract minPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D; + + /** + * Computes the 2D average pooling of an image. + * @param x The input image, must be rank 3. + * @param fSize The field size of the max pool. + * @param stride The stride of the max pool. + * @param pad The padding of each side of the input NDArray. Will pad equally + * on all sides. + */ + avgPool(x: Array3D, fSize: number, stride: number, pad: number): Array3D { + util.assert( + x.rank === 3, + `Error in avgPool: x must be rank 3 but got rank ${x.rank}.`); + return this.track(this.avgPoolInternal(x, fSize, stride, pad)); + } + protected abstract avgPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D; + + /* + * Bilinear resize a 3D array per each channel to a new 2D shape. + * @param x The input Array3D. + * @param newShape2D The new shape to resize the Array3D to. Each channel is + * resized individually. + * @param alignCorners An optional bool. Defaults to False. If true, rescale + * input by (new_height - 1) / (height - 1), which exactly aligns the 4 + * corners of images and resized images. If false, rescale by new_height / + * height. Treat similarly the width dimension. + */ + resizeBilinear3D( + x: Array3D, newShape2D: [number, number], alignCorners = false): Array3D { + util.assert( + x.rank === 3, + `Error in resizeBilinear3D: x must be rank 3 but got rank ${x.rank}.`); + util.assert( + newShape2D.length === 2, + `Error in resizeBilinear3D: new shape must 2D, but got shape ` + + `${newShape2D}.`); + return this.track( + this.resizeBilinear3DInternal(x, newShape2D, alignCorners)); + } + protected abstract resizeBilinear3DInternal( + x: Array3D, newShape2D: [number, number], alignCorners: boolean): Array3D; + + /** + * Batch normalization 3D. Mean, variance, scale, and offset can be of two + * shapes: 1) The same shape as the input: an Array3D. 2) In the common case, + * the depth dimension is the last dimension of x, so the values would be an + * Array1D of shape [depth]. + * @param x The input NDArray. + * @param mean A mean NDArray. + * @param variance A variance NDArray. + * @param varianceEpsilon A small float number to avoid dividing by 0. + * @param scale A scale NDArray. + * @param offset An offset NDArray. + */ + batchNormalization3D( + x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D, + varianceEpsilon = .001, scale?: Array3D|Array1D, + offset?: Array3D|Array1D): Array3D { + util.assert( + x.rank === 3, + `Error in batchNormalization3D: x must be rank 3 but got rank ` + + `${x.rank}.`); + util.assert( + mean.rank === 3 || mean.rank === 1, + `Error in batchNormalization3D: mean must be rank 3 or rank 1 but ` + + `got rank ${mean.rank}.`); + util.assert( + variance.rank === 3 || variance.rank === 1, + `Error in batchNormalization3D: variance must be rank 3 or rank 1 ` + + `but got rank ${variance.rank}.`); + if (scale != null) { + util.assert( + scale.rank === 3 || scale.rank === 1, + `Error in batchNormalization3D: scale must be rank 3 or rank 1 ` + + `but got rank ${scale!.rank}.`); + } + if (offset != null) { + util.assert( + offset.rank === 3 || offset.rank === 1, + `Error in batchNormalization3D: offset must be rank 3 or rank 1 ` + + `but got rank ${offset!.rank}.`); + } + + return this.track(this.batchNormalization3DInternal( + x, mean, variance, varianceEpsilon, scale, offset)); + } + protected abstract batchNormalization3DInternal( + x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D, + varianceEpsilon: number, scale?: Array3D|Array1D, + offset?: Array3D|Array1D): Array3D; +} + +export enum MatrixOrientation { + REGULAR, + TRANSPOSED +} diff --git a/src/math/math_cpu.ts b/src/math/math_cpu.ts new file mode 100644 index 0000000000..30ba4524fe --- /dev/null +++ b/src/math/math_cpu.ts @@ -0,0 +1,898 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../math/conv_util'; +import * as util from '../util'; + +import * as concat3d_util from './concat3d_util'; +import * as copy2D_util from './copy2d_util'; +import {MatrixOrientation, NDArrayMath} from './math'; +import {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray'; + +export class NDArrayMathCPU extends NDArrayMath { + constructor(safeMode = false) { + super(safeMode); + } + + protected cloneInternal(ndarray: T): T { + return NDArray.make( + ndarray.shape, {values: new Float32Array(ndarray.getValues())}); + } + + protected reshapeInternal( + ndarray: T1, newShape: number[]): T2 { + return this.cloneInternal(ndarray).reshape(newShape); + } + + protected slice2DInternal( + input: Array2D, beginRowCol: [number, number], + sizeRowCol: [number, number]): Array2D { + const result = Array2D.zeros(sizeRowCol); + this.copy2DInternal( + input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + } + + protected copy2DInternal( + source: Array2D, sourceBeginRowCol: [number, number], + sourceSizeRowCol: [number, number], dest: Array2D, + destBeginRowCol: [number, number], + destSizeRowCol: [number, number]): void { + copy2D_util.validateShapes(sourceSizeRowCol, destSizeRowCol); + const srcValues = source.getValues(); + const dstValues = dest.getValues(); + const n = sourceSizeRowCol[0] * sourceSizeRowCol[1]; + for (let i = 0; i < n; ++i) { + const srcRow = sourceBeginRowCol[0] + Math.floor(i / sourceSizeRowCol[1]); + const srcCol = sourceBeginRowCol[1] + (i % sourceSizeRowCol[1]); + const srcOff = srcRow * source.shape[1] + srcCol; + const dstRow = destBeginRowCol[0] + Math.floor(i / destSizeRowCol[1]); + const dstCol = destBeginRowCol[1] + (i % destSizeRowCol[1]); + const dstOff = dstRow * dest.shape[1] + dstCol; + dstValues[dstOff] = srcValues[srcOff]; + } + } + + protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D { + const outputShape = + concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + + const values = NDArray.zeros(outputShape); + + for (let i = 0; i < outputShape[0]; i++) { + for (let j = 0; j < outputShape[1]; j++) { + for (let k = 0; k < outputShape[2]; k++) { + // Shader begins. + const index: [number, number, number] = [i, j, k]; + let value: number; + if (index[axis] < x1.shape[axis]) { + value = x1.get(i, j, k); + } else { + index[axis] -= x1.shape[axis]; + const [i2, j2, k2] = index; + value = x2.get(i2, j2, k2); + } + + values.set(value, i, j, k); + } + } + } + + return values; + } + + protected scalarPlusArrayInternal(c: Scalar, a: T): T { + const resultValues = new Float32Array(a.size); + const aValues = a.getValues(); + const cVal = c.get(); + for (let i = 0; i < resultValues.length; ++i) { + resultValues[i] = cVal + aValues[i]; + } + return NDArray.make(a.shape, {values: resultValues}); + } + + protected scaledArrayAddInternal( + c1: Scalar, a: T, c2: Scalar, b: T) { + const cValues = new Float32Array(a.size); + const aValues = a.getValues(); + const bValues = b.getValues(); + const c1Val = c1.get(); + const c2Val = c2.get(); + for (let i = 0; i < cValues.length; ++i) { + cValues[i] = c1Val * aValues[i] + c2Val * bValues[i]; + } + return NDArray.make(a.shape, {values: cValues}); + } + + protected scalarTimesArrayInternal(c: Scalar, a: T): T { + const newValues = new Float32Array(a.size); + const aValues = a.getValues(); + const cVal = c.get(); + for (let i = 0; i < aValues.length; ++i) { + newValues[i] = cVal * aValues[i]; + } + return NDArray.make(a.shape, {values: newValues}); + } + + protected scalarMinusArrayInternal(c: Scalar, a: T): T { + const negA = this.negInternal(a); + const result = this.scalarPlusArrayInternal(c, negA); + + negA.dispose(); + + return result; + } + + protected arrayMinusScalarInternal(a: T, c: Scalar): T { + const negC = this.negInternal(c); + const result = this.scalarPlusArrayInternal(negC, a); + + negC.dispose(); + + return result; + } + + protected negInternal(a: T): T { + return this.scalarTimesArrayInternal(Scalar.NEG_ONE, a); + } + + protected addInternal(a: T, b: T): T { + return this.scaledArrayAddInternal(Scalar.ONE, a, Scalar.ONE, b); + } + + protected subInternal(a: T, b: T): T { + return this.scaledArrayAddInternal(Scalar.ONE, a, Scalar.NEG_ONE, b); + } + + protected matMulInternal( + a: Array2D, b: Array2D, aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Array2D { + const sharedDim = + (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + + const leftDim = + (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + const rightDim = + (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + + const normalGetter = (matrix: Array2D, i: number, j: number) => + matrix.get(i, j); + const transposedGetter = (matrix: Array2D, i: number, j: number) => + matrix.get(j, i); + + const aGetter = (aOrientation === MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + const bGetter = (bOrientation === MatrixOrientation.REGULAR) ? + normalGetter : + transposedGetter; + const values = new Float32Array(leftDim * rightDim); + let index = 0; + + for (let i = 0; i < leftDim; ++i) { + for (let j = 0; j < rightDim; ++j) { + let sum = 0; + for (let k = 0; k < sharedDim; ++k) { + // TODO: optimize CPU matmul. + sum += aGetter(a, i, k) * bGetter(b, k, j); + } + values[index++] = sum; + } + } + return Array2D.new([leftDim, rightDim], values); + } + + protected elementWiseMulInternal(a: T, b: T): T { + const newValues = new Float32Array(a.size); + const aValues = a.getValues(); + const bValues = b.getValues(); + for (let i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] * bValues[i]; + } + return NDArray.make(a.shape, {values: newValues}); + } + + protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D { + const maxRow = Math.max(a.shape[0], b.shape[0]); + const maxCol = Math.max(a.shape[1], b.shape[1]); + + const values = new Float32Array(maxRow * maxCol); + let index = 0; + for (let row = 0; row < maxRow; row++) { + for (let col = 0; col < maxCol; col++) { + values[index++] = a.get(row % a.shape[0], col % a.shape[1]) * + b.get(row % b.shape[0], col % b.shape[1]); + } + } + return Array2D.new([maxRow, maxCol], values); + } + + protected divideInternal(a: T, b: T): T { + const newValues = new Float32Array(a.size); + const aValues = a.getValues(); + const bValues = b.getValues(); + for (let i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / bValues[i]; + } + return NDArray.make(a.shape, {values: newValues}); + } + + protected scalarDividedByArrayInternal(c: Scalar, a: T): + T { + const newValues = new Float32Array(a.size); + const aValues = a.getValues(); + const cValue = c.get(); + for (let i = 0; i < aValues.length; ++i) { + newValues[i] = cValue / aValues[i]; + } + return NDArray.make(a.shape, {values: newValues}); + } + + protected arrayDividedByScalarInternal(a: T, c: Scalar): + T { + const newValues = new Float32Array(a.size); + const aValues = a.getValues(); + const cValue = c.get(); + for (let i = 0; i < aValues.length; ++i) { + newValues[i] = aValues[i] / cValue; + } + return NDArray.make(a.shape, {values: newValues}); + } + + protected sumInternal(ndarray: NDArray): Scalar { + let sum = 0; + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + sum += values[i]; + } + return Scalar.new(sum); + } + + protected argMinInternal(ndarray: NDArray): Scalar { + let min = Number.MAX_VALUE; + let minIndex = -1; + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + const value = values[i]; + if (isNaN(value)) { + return Scalar.new(NaN); + } + if (value < min) { + min = value; + minIndex = i; + } + } + return Scalar.new(minIndex); + } + + protected argMaxInternal(ndarray: NDArray): Scalar { + let max = Number.NEGATIVE_INFINITY; + let maxIndex = -1; + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + const value = values[i]; + if (isNaN(value)) { + return Scalar.new(NaN); + } + if (value > max) { + max = value; + maxIndex = i; + } + } + return Scalar.new(maxIndex); + } + + protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar { + const argMax1 = this.argMaxInternal(x1).get(); + const argMax2 = this.argMaxInternal(x2).get(); + if (isNaN(argMax1) || isNaN(argMax2)) { + return Scalar.new(NaN); + } + return Scalar.new(+(argMax1 === argMax2)); + } + + protected topKInternal(ndarray: NDArray, k: number): + {values: Array1D, indices: Array1D} { + const values = ndarray.getValues(); + const valuesAndIndices: Array<{value: number, index: number}> = []; + for (let i = 0; i < values.length; i++) { + valuesAndIndices.push({value: values[i], index: i}); + } + valuesAndIndices.sort((a, b) => { + return b.value - a.value; + }); + const topkValues = new Float32Array(k); + const topkIndices = new Float32Array(k); + for (let i = 0; i < k; i++) { + topkValues[i] = valuesAndIndices[i].value; + topkIndices[i] = valuesAndIndices[i].index; + } + return {values: Array1D.new(topkValues), indices: Array1D.new(topkIndices)}; + } + + protected minInternal(ndarray: NDArray): Scalar { + const values = ndarray.getValues(); + let min = values[0]; + for (let i = 1; i < values.length; ++i) { + const value = values[i]; + if (isNaN(value)) { + return Scalar.new(NaN); + } + if (value < min) { + min = value; + } + } + return Scalar.new(min); + } + + protected maxInternal(ndarray: NDArray): Scalar { + const values = ndarray.getValues(); + let max = values[0]; + for (let i = 1; i < values.length; ++i) { + const value = values[i]; + if (isNaN(value)) { + return Scalar.new(NaN); + } + if (value > max) { + max = value; + } + } + return Scalar.new(max); + } + + protected expInternal(ndarray: T): T { + const values = ndarray.getValues(); + const newValues = new Float32Array(values.length); + for (let i = 0; i < values.length; ++i) { + newValues[i] = Math.exp(values[i]); + } + return NDArray.make(ndarray.shape, {values: newValues}); + } + + protected logInternal(ndarray: T): T { + const values = ndarray.getValues(); + const newValues = new Float32Array(values.length); + for (let i = 0; i < values.length; ++i) { + const value = values[i]; + newValues[i] = Math.log(value); + } + return NDArray.make(ndarray.shape, {values: newValues}); + } + + protected logSumExpInternal(ndarray: NDArray): Scalar { + const xMax = this.max(ndarray); + const a = this.arrayMinusScalar(ndarray, xMax); + const b = this.exp(a); + const c = this.sum(b); + const d = this.log(c); + const result = this.add(xMax, d); + + xMax.dispose(); + a.dispose(); + b.dispose(); + c.dispose(); + d.dispose(); + + return result; + } + + protected reluInternal(ndarray: T): T { + const resultValues = new Float32Array(ndarray.size); + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + resultValues[i] = Math.max(0, values[i]); + } + return NDArray.make(ndarray.shape, {values: resultValues}); + } + + protected sigmoidInternal(ndarray: T): T { + const resultValues = new Float32Array(ndarray.size); + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + resultValues[i] = 1 / (1 + Math.exp(-values[i])); + } + return NDArray.make(ndarray.shape, {values: resultValues}); + } + + protected tanhInternal(ndarray: T): T { + const resultValues = new Float32Array(ndarray.size); + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + resultValues[i] = util.tanh(values[i]); + } + return NDArray.make(ndarray.shape, {values: resultValues}); + } + + protected sinInternal(ndarray: T): T { + const resultValues = new Float32Array(ndarray.size); + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + resultValues[i] = Math.sin(values[i]); + } + return NDArray.make(ndarray.shape, {values: resultValues}); + } + + protected stepInternal(ndarray: T): T { + const resultValues = new Float32Array(ndarray.size); + const values = ndarray.getValues(); + for (let i = 0; i < values.length; ++i) { + const value = values[i]; + resultValues[i] = value > 0 ? 1 : (value < 0 ? 0 : value); + } + return NDArray.make(ndarray.shape, {values: resultValues}); + } + + /** + * image is of shape [r, c, d1]. + * weights is of shape [F, F, d1, d2]. + */ + protected conv2dInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + pad: number): Array3D { + const [xRows, xCols, inputDepth] = x.shape; + const fieldSize = weights.shape[0]; + const outputDepth = weights.shape[3]; + const outputShape = conv_util.computeOutputShape3D( + [xRows, xCols, inputDepth], fieldSize, outputDepth, stride, pad); + const y = Array3D.zeros(outputShape); + for (let d2 = 0; d2 < outputDepth; ++d2) { + for (let yR = 0; yR < y.shape[0]; ++yR) { + const xRCorner = yR * stride - pad; + const xRMin = Math.max(0, xRCorner); + const xRMax = Math.min(xRows, fieldSize + xRCorner); + for (let yC = 0; yC < y.shape[1]; ++yC) { + const xCCorner = yC * stride - pad; + const xCMin = Math.max(0, xCCorner); + const xCMax = Math.min(xCols, fieldSize + xCCorner); + let dotProd = 0; + for (let xR = xRMin; xR < xRMax; ++xR) { + const wR = xR - xRCorner; + for (let xC = xCMin; xC < xCMax; ++xC) { + const wC = xC - xCCorner; + for (let d1 = 0; d1 < inputDepth; ++d1) { + const pixel = x.get(xR, xC, d1); + const weight = weights.get(wR, wC, d1, d2); + dotProd += pixel * weight; + } + } + } + const bias = (biases != null) ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + } + + protected conv2dBackPropInternal( + x: Array3D, dy: Array3D, weights: Array4D, stride: number, + pad: number): {dx: Array3D, dw: Array4D, db: Array1D} { + const fSize = weights.shape[0]; + const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + const db = this.conv2dDerBias(dy); + const dx = this.conv2dTransposeInternal(dy, weights, null, stride, pad); + return {dx, db, dw}; + } + + /** + * image is of shape [r, c, d1]. + * weights is of shape [F, F, d1, d2]. + */ + protected conv2dTransposeInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number, + origPad: number): Array3D { + const fSize = weights.shape[0]; + const pad = fSize - 1 - origPad; + const origInputDepth = weights.shape[2]; + const origOutputDepth = weights.shape[3]; + const [xRows, xCols, xDepth] = x.shape; + + // Dilate the input. + const xRowsDilated = (xRows - 1) * origStride + 1; + const xColsDilated = (xCols - 1) * origStride + 1; + + const outputShape = conv_util.computeOutputShape3D( + [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, + pad); + const y = Array3D.zeros(outputShape); + for (let d2 = 0; d2 < origInputDepth; ++d2) { + for (let yR = 0; yR < y.shape[0]; ++yR) { + const xRCorner = yR - pad; + const xRMin = Math.max(0, Math.ceil(xRCorner / origStride)); + const xRMax = Math.min(xRows, (fSize + xRCorner) / origStride); + + for (let yC = 0; yC < y.shape[1]; ++yC) { + const xCCorner = yC - pad; + const xCMin = Math.max(0, Math.ceil(xCCorner / origStride)); + const xCMax = Math.min(xCols, (fSize + xCCorner) / origStride); + + let dotProd = 0; + for (let xR = xRMin; xR < xRMax; ++xR) { + const wR = xR * origStride - xRCorner; + + for (let xC = xCMin; xC < xCMax; ++xC) { + const wC = xC * origStride - xCCorner; + + for (let d1 = 0; d1 < origOutputDepth; ++d1) { + const pixel = x.get(xR, xC, d1); + const weight = + weights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + const bias = biases != null ? biases.get(d2) : 0; + y.set(dotProd + bias, yR, yC, d2); + } + } + } + return y; + } + + /** + * image is of shape [r, c, d1]. + * weights is of shape [F, F, d1, d2]. + */ + protected conv2dTransposeShaderLike( + x: Array3D, origWeights: Array4D, origStride: number, + origPad: number): Array3D { + const fSize = origWeights.shape[0]; + const pad = fSize - 1 - origPad; + const origInputDepth = origWeights.shape[2]; + const origOutputDepth = origWeights.shape[3]; + const [xRows, xCols, xDepth] = x.shape; + + // Dilate the input. + const xRowsDilated = (xRows - 1) * origStride + 1; + const xColsDilated = (xCols - 1) * origStride + 1; + + const outputShape = conv_util.computeOutputShape3D( + [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, + pad); + const y = Array3D.zeros(outputShape); + + for (let d2 = 0; d2 < origInputDepth; ++d2) { + for (let yR = 0; yR < y.shape[0]; ++yR) { + for (let yC = 0; yC < y.shape[1]; ++yC) { + // Shader code begins. + const xRCorner = yR - pad; + const xCCorner = yC - pad; + let dotProd = 0; + for (let wR = 0; wR < fSize; ++wR) { + const xR = (xRCorner + wR) / origStride; + if (xR < 0 || xR >= xRows || Math.floor(xR) !== xR) { + continue; + } + for (let wC = 0; wC < fSize; ++wC) { + const xC = (xCCorner + wC) / origStride; + if (xC < 0 || xC >= xCols || Math.floor(xC) !== xC) { + continue; + } + for (let d1 = 0; d1 < origOutputDepth; ++d1) { + const pixel = x.get(xR, xC, d1); + const weight = + origWeights.get(fSize - 1 - wR, fSize - 1 - wC, d2, d1); + dotProd += pixel * weight; + } + } + } + y.set(dotProd, yR, yC, d2); + } + } + } + return y; + } + + conv2dDerWeights( + x: Array3D, dY: Array3D, fSize: number, stride: number, + zeroPad: number): Array4D { + const inputDepth = x.shape[2]; + const outputDepth = dY.shape[2]; + const weightsShape = + conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + const dW = Array4D.zeros(weightsShape); + + const yNumRows = dY.shape[0]; + const yNumCols = dY.shape[1]; + const xNumRows = x.shape[0]; + const xNumCols = x.shape[1]; + + for (let wR = 0; wR < fSize; ++wR) { + const yRMin = Math.max(0, Math.ceil((zeroPad - wR) / stride)); + const yRMax = Math.min(yNumRows, (xNumRows + zeroPad - wR) / stride); + + for (let wC = 0; wC < fSize; ++wC) { + const yCMin = Math.max(0, Math.ceil((zeroPad - wC) / stride)); + const yCMax = Math.min(yNumCols, (xNumCols + zeroPad - wC) / stride); + + for (let d1 = 0; d1 < inputDepth; ++d1) { + for (let d2 = 0; d2 < outputDepth; ++d2) { + // Need to convolve. + let dotProd = 0; + for (let yR = yRMin; yR < yRMax; ++yR) { + const xR = wR + yR * stride - zeroPad; + for (let yC = yCMin; yC < yCMax; ++yC) { + const xC = wC + yC * stride - zeroPad; + dotProd += x.get(xR, xC, d1) * dY.get(yR, yC, d2); + } + } + dW.set(dotProd, wR, wC, d1, d2); + } + } + } + } + return dW; + } + + conv2dDerBias(dY: Array3D): Array1D { + const outputDepth = dY.shape[2]; + const numRows = dY.shape[0]; + const numCols = dY.shape[1]; + const values = new Float32Array(outputDepth); + for (let d2 = 0; d2 < outputDepth; ++d2) { + let sum = 0; + for (let r = 0; r < numRows; ++r) { + for (let c = 0; c < numCols; ++c) { + sum += dY.get(r, c, d2); + } + } + values[d2] = sum; + } + return Array1D.new(values); + } + + protected switchDimInternal(t: T, newDim: number[]): T { + const newShape: number[] = new Array(t.rank); + for (let i = 0; i < newShape.length; i++) { + newShape[i] = t.shape[newDim[i]]; + } + const resultValues = new Float32Array(t.size); + const values = t.getValues(); + const result = NDArray.make(newShape, {values: resultValues}); + for (let i = 0; i < t.size; ++i) { + const loc = t.indexToLoc(i); + + // Permute location. + const newLoc: number[] = new Array(loc.length); + for (let i = 0; i < newLoc.length; i++) { + newLoc[i] = loc[newDim[i]]; + } + + const newIndex = result.locToIndex(newLoc); + resultValues[newIndex] = values[i]; + } + return result; + } + + private pool( + x: Array3D, fSize: number, stride: number, pad: number, + poolType: 'max'|'min'|'avg') { + const [xRows, xCols, depth] = x.shape; + const outputShape = conv_util.computeOutputShape3D( + [xRows, xCols, depth], fSize, depth, stride, pad); + const y = Array3D.zeros(outputShape); + for (let d = 0; d < depth; ++d) { + for (let yR = 0; yR < y.shape[0]; ++yR) { + const xRCorner = yR * stride - pad; + const xRMin = Math.max(0, xRCorner); + const xRMax = Math.min(xRows, fSize + xRCorner); + for (let yC = 0; yC < y.shape[1]; ++yC) { + const xCCorner = yC * stride - pad; + const xCMin = Math.max(0, xCCorner); + const xCMax = Math.min(xCols, fSize + xCCorner); + + + let minMaxValue = + (poolType === 'max' ? Number.NEGATIVE_INFINITY : + Number.POSITIVE_INFINITY); + let avgValue = 0; + + for (let xR = xRMin; xR < xRMax; ++xR) { + const wR = xR - xRCorner; + for (let xC = xCMin; xC < xCMax; ++xC) { + const wC = xC - xCCorner; + const pixel = x.get(xR, xC, d); + if (isNaN(pixel)) { + minMaxValue = NaN; + avgValue = NaN; + break; + } + if ((poolType === 'max' && pixel > minMaxValue) || + (poolType === 'min' && pixel < minMaxValue)) { + minMaxValue = pixel; + } else if (poolType === 'avg') { + avgValue += pixel / (fSize * fSize); + } + } + if (isNaN(minMaxValue)) { + break; + } + } + y.set(poolType === 'avg' ? avgValue : minMaxValue, yR, yC, d); + } + } + } + return y; + } + + protected maxPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + return this.pool(x, fSize, stride, pad, 'max'); + } + + maxPoolPositions(x: Array3D, fSize: number, stride: number, pad: number) { + const [xRows, xCols, depth] = x.shape; + const outputShape = + conv_util.computeOutputShape3D(x.shape, fSize, depth, stride, pad); + const maxPositions = Array3D.zeros(outputShape); + for (let d = 0; d < depth; ++d) { + for (let yR = 0; yR < outputShape[0]; ++yR) { + const xRCorner = yR * stride - pad; + const xRMin = Math.max(0, xRCorner); + const xRMax = Math.min(xRows, fSize + xRCorner); + for (let yC = 0; yC < outputShape[1]; ++yC) { + const xCCorner = yC * stride - pad; + const xCMin = Math.max(0, xCCorner); + const xCMax = Math.min(xCols, fSize + xCCorner); + let maxValue = Number.NEGATIVE_INFINITY; + let maxPosition = -1; + for (let xR = xRMin; xR < xRMax; ++xR) { + const wR = xR - xRCorner; + for (let xC = xCMin; xC < xCMax; ++xC) { + const wC = xC - xCCorner; + const pixel = x.get(xR, xC, d); + if (pixel > maxValue) { + maxValue = pixel; + maxPosition = wR * fSize + wC; + } + } + } + maxPositions.set(maxPosition, yR, yC, d); + } + } + } + return maxPositions; + } + + protected maxPoolBackpropInternal( + dy: Array3D, x: Array3D, fSize: number, origStride: number, + origPad: number): Array3D { + const maxPositions = this.maxPoolPositions(x, fSize, origStride, origPad); + const pad = fSize - 1 - origPad; + const [dyRows, dyCols, depth] = dy.shape; + + // Dilate the input. + const dyRowsDilated = (dyRows - 1) * origStride + 1; + const dxColsDilated = (dyCols - 1) * origStride + 1; + + const outputShape = conv_util.computeOutputShape3D( + [dyRowsDilated, dxColsDilated, depth], fSize, depth, 1, pad); + const dx = Array3D.zeros(outputShape); + + for (let d = 0; d < depth; ++d) { + for (let dxR = 0; dxR < dx.shape[0]; ++dxR) { + for (let dxC = 0; dxC < dx.shape[1]; ++dxC) { + // Shader code begins. + const dyRCorner = dxR - pad; + const dyCCorner = dxC - pad; + let dotProd = 0; + for (let wR = 0; wR < fSize; ++wR) { + const dyR = (dyRCorner + wR) / origStride; + if (dyR < 0 || dyR >= dyRows || Math.floor(dyR) !== dyR) { + continue; + } + for (let wC = 0; wC < fSize; ++wC) { + const dyC = (dyCCorner + wC) / origStride; + if (dyC < 0 || dyC >= dyCols || Math.floor(dyC) !== dyC) { + continue; + } + const maxPos = fSize * fSize - 1 - maxPositions.get(dyR, dyC, d); + const curPos = wR * fSize + wC; + + const mask = maxPos === curPos ? 1 : 0; + if (mask === 0) { + continue; + } + + const pixel = dy.get(dyR, dyC, d); + dotProd += pixel * mask; + } + } + dx.set(dotProd, dxR, dxC, d); + } + } + } + return dx; + } + + protected minPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + return this.pool(x, fSize, stride, pad, 'min'); + } + + protected avgPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + return this.pool(x, fSize, stride, pad, 'avg'); + } + + protected resizeBilinear3DInternal( + x: Array3D, newShape2D: [number, number], + alignCorners: boolean): Array3D { + const output = Array3D.zeros([newShape2D[0], newShape2D[1], x.shape[2]]); + + const effectiveInputSize = + alignCorners ? [x.shape[0] - 1, x.shape[1] - 1, x.shape[2]] : x.shape; + const effectiveOutputSize = alignCorners ? + [output.shape[0] - 1, output.shape[1] - 1, output.shape[2]] : + output.shape; + for (let r = 0; r < output.shape[0]; r++) { + for (let c = 0; c < output.shape[1]; c++) { + for (let d = 0; d < output.shape[2]; d++) { + // Begin shader. + + // Compute the fractional index of the source. + const sourceFracRow = + (effectiveInputSize[0]) * r / (effectiveOutputSize[0]); + const sourceFracCol = + (effectiveInputSize[1]) * c / (effectiveOutputSize[1]); + + const sourceRowFloor = Math.floor(sourceFracRow); + const sourceRowCeil = + Math.min(x.shape[0] - 1, Math.ceil(sourceFracRow)); + const sourceColFloor = Math.floor(sourceFracCol); + const sourceColCeil = + Math.min(x.shape[1] - 1, Math.ceil(sourceFracCol)); + + const topLeft = x.get(sourceRowFloor, sourceColFloor, d); + const bottomLeft = x.get(sourceRowCeil, sourceColFloor, d); + const topRight = x.get(sourceRowFloor, sourceColCeil, d); + const bottomRight = x.get(sourceRowCeil, sourceColCeil, d); + + const rowFrac = sourceFracRow - sourceRowFloor; + const colFrac = sourceFracCol - sourceColFloor; + + const top = topLeft + (topRight - topLeft) * colFrac; + const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac; + const newValue = top + (bottom - top) * rowFrac; + + output.set(newValue, r, c, d); + } + } + } + + return output; + } + + protected batchNormalization3DInternal( + x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D, + varianceEpsilon = .001, scale?: Array3D|Array1D, + offset?: Array3D|Array1D): Array3D { + const xValues = x.getValues(); + const meanValues = mean.getValues(); + const varianceValues = variance.getValues(); + const scaleValues = scale ? scale.getValues() : new Float32Array([1]); + const offsetValues = offset ? offset.getValues() : new Float32Array([0]); + const outValues = new Float32Array(xValues.length); + + for (let i = 0; i < xValues.length; i++) { + outValues[i] = offsetValues[i % offsetValues.length] + + (xValues[i] - meanValues[i % meanValues.length]) * + scaleValues[i % scaleValues.length] / + Math.sqrt( + varianceValues[i % varianceValues.length] + varianceEpsilon); + } + return NDArray.make(x.shape, {values: outValues}); + } +} diff --git a/src/math/math_cpu_test.ts b/src/math/math_cpu_test.ts new file mode 100644 index 0000000000..97bd3f84b5 --- /dev/null +++ b/src/math/math_cpu_test.ts @@ -0,0 +1,1550 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../test_util'; +import * as util from '../util'; + +import {MatrixOrientation} from './math'; +import {NDArrayMathCPU} from './math_cpu'; +import {Array1D, Array2D, Array3D, NDArray, Scalar} from './ndarray'; + +describe('NDArrayMathCPU clone', () => { + it('returns a ndarray with the same shape and data', () => { + const math = new NDArrayMathCPU(); + const a = Array2D.new([3, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9]); + const aPrime = math.clone(a); + expect(aPrime.shape).toEqual(a.shape); + expect(aPrime.getValues()).toEqual(a.getValues()); + }); +}); + +describe('NDArrayMathCPU slice2D', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('slicing a 1x1 from a 1x1 returns a 1x1', () => { + const a = Array2D.new([1, 1], [0]); + const b = math.slice2D(a, [0, 0], [1, 1]); + expect(b.shape).toEqual([1, 1]); + }); + + it('returns a ndarray of slice size', () => { + const a = Array2D.zeros([100, 100]); + const b = math.slice2D(a, [0, 0], [12, 34]); + expect(b.shape).toEqual([12, 34]); + }); + + it('returns the upper-left submatrix when begin is [0, 0]', () => { + const a = NDArray.randUniform([10, 10], -1, 1); + const b = math.slice2D(a, [0, 0], [2, 2]); + const aValues = a.getValues(); + const expected = + new Float32Array([aValues[0], aValues[1], aValues[10], aValues[11]]); + test_util.expectArraysClose(b.getValues(), expected, 0); + }); + + it('returns the rectangle specified', () => { + const a = Array2D.new([4, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const b = math.slice2D(a, [1, 1], [3, 2]); + const expected = new Float32Array([5, 6, 8, 9, 11, 12]); + expect(b.getValues()).toEqual(expected); + }); + + it('throws when requesting out of bounds slice', () => { + const a = Array2D.new([4, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + expect(() => math.slice2D(a, [1, 1], [10, 10])).toThrowError(); + }); +}); + +describe('NDArrayMathCPU copy2D', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('throws an error if source and dest shapes have different areas', () => { + const source = Array2D.zeros([100, 100]); + const dest = Array2D.zeros([100, 100]); + const sourceSize: [number, number] = [20, 20]; + const destSize: [number, number] = [5, 5]; + expect( + () => math.copy2D(source, [0, 0], sourceSize, dest, [0, 0], destSize)) + .toThrowError(); + }); + + it('copies a src shape into a dst shape', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + math.copy2D(source, [1, 1], [2, 3], dest, [2, 0], [3, 2]); + expect(dest.getValues()).toEqual(new Float32Array([ + 0, 0, 0, 0, 6, 7, 8, 10, 11, 12, 0, 0 + ])); + }); + + it('throws when requesting out of bounds source copy', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + + expect(() => math.copy2D(source, [1, 1], [10, 10], dest, [2, 0], [ + 3, 2 + ])).toThrowError(); + }); + + it('throws when requesting out of bounds dest copy', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + + expect(() => math.copy2D(source, [1, 1], [2, 3], dest, [2, 0], [ + 3, 10 + ])).toThrowError(); + }); +}); + +describe('NDArrayMathCPU concat3D', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('shapes correct concat axis=0', () => { + const ndarray1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const ndarray2 = Array3D.new([1, 1, 3], [4, 5, 6]); + const values = math.concat3D(ndarray1, ndarray2, 0); + expect(values.shape).toEqual([2, 1, 3]); + expect(values.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('concat axis=0', () => { + const ndarray1 = Array3D.new([1, 2, 3], [1, 11, 111, 2, 22, 222]); + const ndarray2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const values = math.concat3D(ndarray1, ndarray2, 0); + expect(values.shape).toEqual([3, 2, 3]); + expect(values.getValues()).toEqual(new Float32Array([ + 1, 11, 111, 2, 22, 222, 5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888 + ])); + }); + + it('shapes correct concat axis=1', () => { + const ndarray1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const ndarray2 = Array3D.new([1, 1, 3], [4, 5, 6]); + const values = math.concat3D(ndarray1, ndarray2, 1); + expect(values.shape).toEqual([1, 2, 3]); + expect(values.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('concat axis=1', () => { + const ndarray1 = Array3D.new([2, 1, 3], [1, 11, 111, 3, 33, 333]); + const ndarray2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const values = math.concat3D(ndarray1, ndarray2, 1); + expect(values.shape).toEqual([2, 3, 3]); + expect(values.getValues()).toEqual(new Float32Array([ + 1, 11, 111, 5, 55, 555, 6, 66, 666, 3, 33, 333, 7, 77, 777, 8, 88, 888 + ])); + }); + + it('shapes correct concat axis=2', () => { + const ndarray1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const ndarray2 = Array3D.new([1, 1, 3], [4, 5, 6]); + const values = math.concat3D(ndarray1, ndarray2, 2); + expect(values.shape).toEqual([1, 1, 6]); + expect(values.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('concat axis=2', () => { + const ndarray1 = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const ndarray2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const values = math.concat3D(ndarray1, ndarray2, 2); + expect(values.shape).toEqual([2, 2, 5]); + expect(values.getValues()).toEqual(new Float32Array([ + 1, 11, 5, 55, 555, 2, 22, 6, 66, 666, + 3, 33, 7, 77, 777, 4, 44, 8, 88, 888 + ])); + }); + + it('concat throws when invalid non-axis shapes, axis=0', () => { + const axis = 0; + const x1 = Array3D.new([1, 1, 3], [1, 11, 111]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); + + it('concat throws when invalid non-axis shapes, axis=1', () => { + const axis = 1; + const x1 = Array3D.new([1, 1, 3], [1, 11, 111]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); + + it('concat throws when invalid non-axis shapes, axis=2', () => { + const axis = 2; + const x1 = Array3D.new([1, 2, 2], [1, 11, 2, 22]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU matMul', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('A x B', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([3, 2], [0, 1, -3, 2, 2, 1]); + const c = math.matMul(a, b); + expect(c.shape).toEqual([2, 2]); + expect(c.getValues()).toEqual(new Float32Array([0, 8, -3, 20])); + }); + + it('A x B^t', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([2, 3], [1, 0, 2, 4, 3, 0]); + const c = math.matMul( + a, b, MatrixOrientation.REGULAR, MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([7, 10, 16, 31]); + expect(c.getValues()).toEqual(expected); + }); + + it('A^t x B', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([2, 3], [1, 0, 2, 4, 3, 0]); + const c = math.matMul( + a, b, MatrixOrientation.TRANSPOSED, MatrixOrientation.REGULAR); + const expected = new Float32Array([17, 12, 2, 22, 15, 4, 27, 18, 6]); + expect(c.getValues()).toEqual(expected); + }); + + it('A^t x B^t', () => { + const a = Array2D.new([3, 2], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([2, 3], [1, 0, 2, 4, 3, 0]); + const c = math.matMul( + a, b, MatrixOrientation.TRANSPOSED, MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([11, 13, 14, 20]); + expect(c.getValues()).toEqual(expected); + }); + + it('A x B^t shapes do not match', () => { + const a = NDArray.zeros([2, 3]); + const b = NDArray.zeros([3, 2]); + const f = () => { + math.matMul( + a, b, MatrixOrientation.REGULAR, MatrixOrientation.TRANSPOSED); + }; + expect(f).toThrowError(); + }); + + it('A^t x B shapes do not match', () => { + const a = NDArray.zeros([2, 3]); + const b = NDArray.zeros([3, 2]); + const f = () => { + math.matMul( + a, b, MatrixOrientation.TRANSPOSED, MatrixOrientation.REGULAR); + }; + expect(f).toThrowError(); + }); + + it('A^t x B^t shapes do not match', () => { + const a = NDArray.zeros([3, 2]); + const b = NDArray.zeros([3, 2]); + const f = () => { + math.matMul( + a, b, MatrixOrientation.TRANSPOSED, MatrixOrientation.TRANSPOSED); + }; + expect(f).toThrowError(); + }); + + it('matmul throws when inner dimensions dont match', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([4, 2], [0, 1, -3, 2, 2, 1, 2, 2]); + expect(() => math.matMul(a, b)).toThrowError(); + }); + + it('matmul throws when passed non matrices', () => { + // tslint:disable-next-line:no-any + const a: any = + Array3D.new([2, 3, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const b = Array2D.new([4, 2], [0, 1, -3, 2, 2, 1, 2, 2]); + expect(() => math.matMul(a, b)).toThrowError(); + expect(() => math.matMul(b, a)).toThrowError(); + }); + + it('Vector times matrix', () => { + const v = Array1D.new([2, 3]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const result = math.vectorTimesMatrix(v, matrix); + + const expected = new Float32Array([11, 16]); + expect(result.getValues()).toEqual(expected); + }); + + it('Vector times matrix throws when not passed a vector', () => { + // tslint:disable-next-line:no-any + const v: any = Array2D.new([2, 2], [1, 2, 3, 4]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + expect(() => math.vectorTimesMatrix(v, matrix)).toThrowError(); + }); + + it('Vector times matrix throws when not passed a matrix', () => { + const v = Array1D.new([2, 3]); + // tslint:disable-next-line:no-any + const matrix: any = Array3D.new([2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]); + expect(() => math.vectorTimesMatrix(v, matrix)).toThrowError(); + }); + + it('Matrix times vector', () => { + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const v = Array1D.new([2, 3]); + const result = math.matrixTimesVector(matrix, v); + + const expected = new Float32Array([8, 18]); + expect(result.getValues()).toEqual(expected); + }); + + it('matrix times vector throws when not passed a vector', () => { + // tslint:disable-next-line:no-any + const v: any = Array2D.new([2, 2], [1, 2, 3, 4]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + expect(() => math.matrixTimesVector(matrix, v)).toThrowError(); + }); + + it('matrix times vector throws when not passed a matrix', () => { + const v = Array1D.new([2, 3]); + // tslint:disable-next-line:no-any + const matrix: any = Array3D.new([2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]); + expect(() => math.matrixTimesVector(matrix, v)).toThrowError(); + }); + + it('Dot product', () => { + const v1 = Array1D.new([2, 3]); + const v2 = Array1D.new([2, 1]); + const result = math.dotProduct(v1, v2); + + expect(result.get()).toEqual(7); + }); + + it('Dot product throws when vectors are different size', () => { + const v1 = Array1D.new([2, 3, 3]); + const v2 = Array1D.new([2, 1]); + expect(() => math.dotProduct(v1, v2)).toThrowError(); + expect(() => math.dotProduct(v2, v1)).toThrowError(); + }); + + it('Dot product throws when passed non vectors', () => { + // tslint:disable-next-line:no-any + const v1: any = Array2D.new([2, 2], [1, 2, 3, 3]); + const v2 = Array1D.new([2, 1]); + expect(() => math.dotProduct(v1, v2)).toThrowError(); + expect(() => math.dotProduct(v2, v1)).toThrowError(); + }); + + it('Outer product', () => { + const v1 = Array1D.new([2, 3]); + const v2 = Array1D.new([2, 1]); + const result = math.outerProduct(v1, v2); + + const expected = new Float32Array([4, 2, 6, 3]); + expect(result.shape).toEqual([2, 2]); + expect(result.getValues()).toEqual(expected); + }); + + it('Dot product propagates NaNs', () => { + const v1 = Array1D.new([2, NaN]); + const v2 = Array1D.new([2, 1]); + const result = math.dotProduct(v1, v2); + expect(result.get()).toEqual(NaN); + }); + + it('Matrix * vector propagates NaNs', () => { + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const v = Array1D.new([2, NaN]); + const result = math.matrixTimesVector(matrix, v); + + const expected = new Float32Array([NaN, NaN]); + expect(result.getValues()).toEqual(expected); + }); +}); + +describe('NDArrayMathCPU element-wise mul/div', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('multiplication with broadcasting.', () => { + // Same shapes, no broadcasting. + let a = Array2D.new([2, 2], [1, 2, 3, 4]); + let b = Array2D.new([2, 2], [5, 4, 3, 2]); + let expected = Array2D.new([2, 2], [5, 8, 9, 8]); + expect(expected.equals(math.elementWiseMulBroadcast(a, b))).toBe(true); + + // Broadcast a over b. + a = Array2D.new([2, 2], [1, 2, 3, 4]); + b = Array2D.new([4, 4], [2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]); + expected = Array2D.new( + [4, 4], [2, 6, 4, 10, 9, 16, 15, 24, 4, 10, 6, 14, 15, 24, 21, 32]); + expect(expected.equals(math.elementWiseMulBroadcast(a, b))).toBe(true); + }); + + it('multiplication, no broadcasting', () => { + const a = Array2D.new([2, 2], [1, 2, 3, 4]); + const b = Array2D.new([2, 2], [5, 4, 3, 2]); + const expected = Array2D.new([2, 2], [5, 8, 9, 8]); + expect(expected.equals(math.elementWiseMul(a, b))).toBe(true); + }); + + it('multiplication propagates NaNs', () => { + const a = Array2D.new([2, 2], [1, 3, 4, 0]); + const b = Array2D.new([2, 2], [NaN, 3, NaN, 3]); + const result = math.elementWiseMul(a, b).getValues(); + expect(result).toEqual(new Float32Array([NaN, 9, NaN, 0])); + }); + + it('mul throws when passed ndarrays of different shapes', () => { + const a = Array2D.new([2, 3], [1, 2, -3, -4, 5, 6]); + const b = Array2D.new([2, 2], [5, 3, 4, -7]); + expect(() => math.elementWiseMul(a, b)).toThrowError(); + expect(() => math.elementWiseMul(b, a)).toThrowError(); + }); + + it('divide', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c = Array2D.new([2, 3], [1, 2, 3, 4, 2, 5]); + const r = math.divide(a, c); + + expect(r.get(0, 0)).toBeCloseTo(1); + expect(r.get(0, 1)).toBeCloseTo(1); + expect(r.get(0, 2)).toBeCloseTo(1); + expect(r.get(1, 0)).toBeCloseTo(1); + expect(r.get(1, 1)).toBeCloseTo(2.5); + expect(r.get(1, 2)).toBeCloseTo(6 / 5); + }); + + it('divide propagates NaNs', () => { + const a = Array2D.new([2, 1], [1, 2]); + const c = Array2D.new([2, 1], [3, NaN]); + const r = math.divide(a, c).getValues(); + expect(r[0]).toBeCloseTo(1 / 3); + expect(r[1]).toEqual(NaN); + }); + + it('divide throws when passed ndarrays of different shapes', () => { + const a = Array2D.new([2, 3], [1, 2, -3, -4, 5, 6]); + const b = Array2D.new([2, 2], [5, 3, 4, -7]); + expect(() => math.divide(a, b)).toThrowError(); + expect(() => math.divide(b, a)).toThrowError(); + }); + + it('scalar divided by array', () => { + const c = Scalar.new(2); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const r = math.scalarDividedByArray(c, a); + + expect(r.get(0, 0)).toBeCloseTo(2 / 1); + expect(r.get(0, 1)).toBeCloseTo(2 / 2); + expect(r.get(0, 2)).toBeCloseTo(2 / 3); + expect(r.get(1, 0)).toBeCloseTo(2 / 4); + expect(r.get(1, 1)).toBeCloseTo(2 / 5); + expect(r.get(1, 2)).toBeCloseTo(2 / 6); + }); + + it('scalar divided by array propagates NaNs', () => { + const c = Scalar.new(NaN); + const a = Array2D.new([1, 3], [1, 2, 3]); + const r = math.scalarDividedByArray(c, a).getValues(); + expect(r).toEqual(new Float32Array([NaN, NaN, NaN])); + }); + + it('scalar divided by array throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + expect(() => math.scalarDividedByArray(c, a)).toThrowError(); + }); + + it('array divided by scalar', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c = Scalar.new(2); + const r = math.arrayDividedByScalar(a, c); + + expect(r.get(0, 0)).toBeCloseTo(1 / 2); + expect(r.get(0, 1)).toBeCloseTo(2 / 2); + expect(r.get(0, 2)).toBeCloseTo(3 / 2); + expect(r.get(1, 0)).toBeCloseTo(4 / 2); + expect(r.get(1, 1)).toBeCloseTo(5 / 2); + expect(r.get(1, 2)).toBeCloseTo(6 / 2); + }); + + it('array divided by scalar propagates NaNs', () => { + const a = Array2D.new([1, 3], [1, 2, NaN]); + const c = Scalar.new(2); + const r = math.arrayDividedByScalar(a, c).getValues(); + expect(r[0]).toBeCloseTo(1 / 2); + expect(r[1]).toBeCloseTo(2 / 2); + expect(r[2]).toEqual(NaN); + }); + + it('array divided by scalar throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + expect(() => math.arrayDividedByScalar(a, c)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU add/sub', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('add', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, 2, -1]); + const expected = Array1D.new([6, 7, 0]); + expect(expected.getValues()).toEqual(math.add(a, b).getValues()); + }); + + it('add propagates NaNs', () => { + const a = Array1D.new([2, 5, NaN]); + const b = Array1D.new([4, 2, -1]); + const res = math.add(a, b).getValues(); + expect(res).toEqual(new Float32Array([6, 7, NaN])); + }); + + it('add throws when passed ndarrays with different shape', () => { + const a = Array1D.new([2, 5, 1, 5]); + const b = Array1D.new([4, 2, -1]); + expect(() => math.add(a, b)).toThrowError(); + expect(() => math.add(b, a)).toThrowError(); + }); + + it('sub', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, 2, -1]); + const expected = Array1D.new([-2, 3, 2]); + expect(expected.getValues()).toEqual(math.sub(a, b).getValues()); + }); + + it('sub propagates NaNs', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, NaN, -1]); + const res = math.sub(a, b).getValues(); + expect(res).toEqual(new Float32Array([-2, NaN, 2])); + }); + + it('sub throws when passed ndarrays with different shape', () => { + const a = Array1D.new([2, 5, 1, 5]); + const b = Array1D.new([4, 2, -1]); + expect(() => math.sub(a, b)).toThrowError(); + expect(() => math.sub(b, a)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU scalarTimesNDArray', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('scalar times ndarray', () => { + const a = Array2D.new([3, 2], [2, -5, 1, 1, 4, 0]); + const c = Scalar.new(2); + const expected = Array2D.new([3, 2], [4, -10, 2, 2, 8, 0]); + expect(expected.getValues()) + .toEqual(math.scalarTimesArray(c, a).getValues()); + }); + + it('scalar times ndarray throws when passed non-scalar', () => { + const a = Array2D.new([3, 2], [2, -5, 1, 1, 4, 0]); + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3, 4]); + expect(() => math.scalarTimesArray(c, a)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU scaledNDArrayAdd', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('Scaled ndarray add', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + const expected = Array2D.new([2, 3], [8, 16, 24, 32, 40, 48]); + expect(math.scaledArrayAdd(c1, a, c2, b).equals(expected)) + .toBe(true); + + // Different sizes throws an error. + const wrongSizeMat = Array2D.new([2, 2], [1, 2, 3, 4]); + expect(() => math.scaledArrayAdd(c1, wrongSizeMat, c2, b)) + .toThrowError(); + }); + + it('throws when passed non-scalars', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c1 = Array1D.randNormal([10]); + const c2 = Scalar.new(2); + + expect(() => math.scaledArrayAdd(c1 as Scalar, a, c2, b)) + .toThrowError(); + expect(() => math.scaledArrayAdd(c2, a, c1 as Scalar, b)) + .toThrowError(); + }); + + it('throws when NDArrays are different shape', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 4], [1, 2, 3, 4, 5, 6, 7, 8]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + expect(() => math.scaledArrayAdd(c1, a, c2, b)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU argmin/max, argmaxequals, min/max', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('Arg max', () => { + expect(math.argMax(Array1D.new([5, 0, 3, 7, 3])).get()).toBe(3); + expect(math.argMax(Array1D.new([-100.3, .3, 11.1, 9.9, 7.33])).get()) + .toBe(2); + expect(math.argMax(Array1D.new([-100.3, -20.0, -10.0, -5])).get()).toBe(3); + }); + + it('Arg max propagates NaNs', () => { + expect(math.argMax(Array1D.new([5, 0, 3, NaN, 3])).get()).toEqual(NaN); + }); + + it('Argmaxequals equals', () => { + const a = Array1D.new([5, 0, 3, 7]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toBe(1); + }); + + it('Argmaxequals not equals', () => { + const a = Array1D.new([5, 0, 3, 1]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toBe(0); + }); + + it('Argmaxequals propagates NaNs', () => { + const a = Array1D.new([5, 3, 1, 3]); + const b = Array1D.new([NaN, -20.0, -10.0, -5]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toEqual(NaN); + }); + + it('throws when given arrays of different shape', () => { + const a = Array1D.new([5, 0, 3, 7, 3, 10]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5, -100]); + expect(() => math.argMaxEquals(a, b)).toThrowError(); + }); + + it('topk', () => { + const topk = math.topK(Array1D.new([1, -1, 100, -5, -10.6, 3.3, 5]), 3); + test_util.expectArraysClose( + topk.values.getValues(), new Float32Array([100, 5, 3.3]), 1e-6); + test_util.expectArraysClose( + topk.indices.getValues(), new Float32Array([2, 6, 5]), 1e-6); + }); + + it('Arg min', () => { + expect(math.argMin(Array1D.new([5, 0, 3, 7, 3])).get()).toBe(1); + expect(math.argMin(Array1D.new([-100.3, .3, 11.1, 9.9, 7.33])).get()) + .toBe(0); + }); + + it('Arg min propagates NaNs', () => { + expect(math.argMin(Array1D.new([5, 0, NaN, 7, 3])).get()).toEqual(NaN); + }); + + it('min', () => { + expect(math.min(Array1D.new([3, -1, 0, 100, -7, 2])).get()).toBe(-7); + }); + + it('min propagates NaNs', () => { + expect(math.min(Array1D.new([3, NaN, 2])).get()).toEqual(NaN); + }); + + it('max', () => { + expect(math.max(Array1D.new([3, -1, 0, 100, -7, 2])).get()).toBe(100); + }); + + it('max propagates NaNs', () => { + expect(math.max(Array1D.new([3, NaN, 2])).get()).toEqual(NaN); + }); +}); + +describe('NDArrayMathCPU log/exp', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('exp', () => { + const r = math.exp(Array1D.new([1, 2, 0])); + + expect(r.get(0)).toBeCloseTo(Math.exp(1)); + expect(r.get(1)).toBeCloseTo(Math.exp(2)); + expect(r.get(2)).toBeCloseTo(1); + }); + + it('exp propagates NaNs', () => { + const a = Array1D.new([1, NaN, 0]); + const r = math.exp(a).getValues(); + expect(r).toEqual(new Float32Array([Math.exp(1), NaN, 1])); + }); + + it('log', () => { + const r = math.log(Array1D.new([1, 2])); + + expect(r.get(0)).toBeCloseTo(Math.log(1)); + expect(r.get(1)).toBeCloseTo(Math.log(2)); + }); + + it('log propagates NaNs', () => { + const r = math.log(Array1D.new([1, NaN])).getValues(); + expect(r).toEqual(new Float32Array([Math.log(1), NaN])); + }); + + it('logSumExp', () => { + const a = Array1D.new([1, 2, -3]); + const result = math.logSumExp(a); + expect(result.get()) + .toBeCloseTo(Math.log(Math.exp(1) + Math.exp(2) + Math.exp(-3))); + }); + + it('logSumExp propagates NaNs', () => { + const a = Array1D.new([1, 2, NaN]); + const result = math.logSumExp(a); + expect(result.get()).toEqual(NaN); + }); +}); + +describe('softmax', () => { + let math: NDArrayMathCPU; + + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('regular test', () => { + const y = math.softmax(Array1D.new([2, 1, 3])); + expect(y.get(0)).toBeCloseTo(0.24472847, 6); + expect(y.get(1)).toBeCloseTo(0.09003057, 6); + expect(y.get(2)).toBeCloseTo(0.66524095, 6); + expect(y.get(0) + y.get(1) + y.get(2)).toBeCloseTo(1, 6); + }); + + it('Overflow', () => { + const y = math.softmax(Array1D.new([10000, 10000])); + expect(y.get(0)).toBeCloseTo(0.5, 3); + expect(y.get(1)).toBeCloseTo(0.5, 3); + }); + + it('Underflow', () => { + const y = math.softmax(Array1D.new([-10000, -10000])); + expect(y.get(0)).toBeCloseTo(0.5, 3); + expect(y.get(1)).toBeCloseTo(0.5, 3); + }); + + it('Huge difference between probabilities', () => { + const y = math.softmax(Array1D.new([-10000, +10000])); + expect(y.get(0)).toBeCloseTo(0.0, 6); + expect(y.get(1)).toBeCloseTo(1, 6); + }); + + it('Propagates NaNs', () => { + const y = math.softmax(Array1D.new([2, 1, NaN])); + expect(y.getValues()).toEqual(new Float32Array([NaN, NaN, NaN])); + }); +}); + +describe('NDArrayMathCPU sum', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('sums values in ndarray', () => { + const a = Array2D.new([3, 2], [1, 2, 3, 0, 0, 1]); + expect(math.sum(a).get()).toBe(7); + }); + + it('propagates NaNs', () => { + const a = Array2D.new([3, 2], [1, 2, 3, NaN, 0, 1]); + expect(math.sum(a).get()).toEqual(NaN); + }); +}); + +describe('NDArrayMathCPU unary ops', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('relu', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1]); + const result = math.relu(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 3, 0])); + }); + + it('relu propagates NaNs', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1, NaN]); + const result = math.relu(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 3, 0, NaN])); + }); + + it('step', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1]); + const result = math.step(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 1, 0])); + }); + + it('step propagates NaNs', () => { + const a = Array1D.new([1, -2, 0, 3, NaN]); + const result = math.step(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 1, NaN])); + }); + + it('neg', () => { + const a = Array1D.new([1, -3, 2, 7, -4]); + expect(math.neg(a).getValues()).toEqual(new Float32Array([ + -1, 3, -2, -7, 4 + ])); + }); + + it('neg propagate NaNs', () => { + const a = Array1D.new([1, -3, 2, 7, NaN]); + expect(math.neg(a).getValues()).toEqual(new Float32Array([ + -1, 3, -2, -7, NaN + ])); + }); + + it('sigmoid', () => { + const a = Array1D.new([3, 5]); + const res = math.sigmoid(a).getValues(); + const expected = [3, 5].map(x => 1 / (1 + Math.exp(-x))); + expect(res).toEqual(new Float32Array(expected)); + }); + + it('sigmoid propagates NaNs', () => { + const a = Array1D.new([3, NaN]); + const res = math.sigmoid(a).getValues(); + expect(res).toEqual(new Float32Array([1 / (1 + Math.exp(-3)), NaN])); + }); + + it('tanh', () => { + const a = Array1D.new([4, -3, 0]); + const res = math.tanh(a).getValues(); + const expected = [util.tanh(4), util.tanh(-3), util.tanh(0)]; + expect(res).toEqual(new Float32Array(expected)); + }); + + it('tanh propagates NaNs', () => { + const a = Array1D.new([4, NaN, 0]); + const res = math.tanh(a).getValues(); + const expected = [util.tanh(4), NaN, util.tanh(0)]; + expect(res).toEqual(new Float32Array(expected)); + }); + + it('sin', () => { + const a = Array1D.new([4, -3, 0]); + const res = math.sin(a).getValues(); + const expected = [Math.sin(4), Math.sin(-3), Math.sin(0)]; + expect(res).toEqual(new Float32Array(expected)); + }); + + it('sin propagates NaNs', () => { + const a = Array1D.new([4, NaN, 0]); + const res = math.sin(a).getValues(); + const expected = [Math.sin(4), NaN, Math.sin(0)]; + expect(res).toEqual(new Float32Array(expected)); + }); +}); + +describe('NDArrayMathCPU scalar OP ndarray', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('c + A', () => { + const c = Scalar.new(5); + const a = Array1D.new([1, 2, 3]); + expect(math.scalarPlusArray(c, a).getValues()).toEqual(new Float32Array([ + 6, 7, 8 + ])); + }); + + it('c + A propagates NaNs', () => { + const c = Scalar.new(NaN); + const a = Array1D.new([1, 2, 3]); + const res = math.scalarPlusArray(c, a).getValues(); + expect(res).toEqual(new Float32Array([NaN, NaN, NaN])); + }); + + it('c + A throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.scalarPlusArray(c, a)).toThrowError(); + }); + + it('c - A', () => { + const c = Scalar.new(5); + const a = Array1D.new([1, 2, 3]); + expect(math.scalarMinusArray(c, a).getValues()).toEqual(new Float32Array([ + 4, 3, 2 + ])); + }); + + it('c - A throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.scalarMinusArray(c, a)).toThrowError(); + }); + + it('A - c', () => { + const a = Array1D.new([1, 2, 3]); + const c = Scalar.new(5); + expect(math.arrayMinusScalar(a, c).getValues()).toEqual(new Float32Array([ + -4, -3, -2 + ])); + }); + + it('A - c propagates NaNs', () => { + const a = Array1D.new([1, NaN, 3]); + const c = Scalar.new(5); + const res = math.arrayMinusScalar(a, c).getValues(); + expect(res).toEqual(new Float32Array([-4, NaN, -2])); + }); + + it('A - c throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.arrayMinusScalar(a, c)).toThrowError(); + }); +}); + +describe('NDArrayMathCPU switchDim', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('Switch dim 2D (no change)', () => { + const t = Array2D.new([2, 4], [1, 11, 2, 22, 3, 33, 4, 44]); + const t2 = math.switchDim(t, [0, 1]); + expect(t2.shape).toEqual(t.shape); + expect(t2.getValues()).toEqual(t.getValues()); + }); + + it('Switch dim 2D (transpose)', () => { + const t = Array2D.new([2, 4], [1, 11, 2, 22, 3, 33, 4, 44]); + const t2 = math.switchDim(t, [1, 0]); + expect(t2.shape).toEqual([4, 2]); + const expected = new Float32Array([1, 3, 11, 33, 2, 4, 22, 44]); + expect(t2.getValues()).toEqual(expected); + }); + + it('Switch dim 3D [r, c, d] => [d, r, c]', () => { + const t = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const t2 = math.switchDim(t, [2, 0, 1]); + expect(t2.shape).toEqual([2, 2, 2]); + const expected = new Float32Array([1, 2, 3, 4, 11, 22, 33, 44]); + expect(t2.getValues()).toEqual(expected); + }); + + it('Switch dim 3D [r, c, d] => [d, c, r]', () => { + const t = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const t2 = math.switchDim(t, [2, 1, 0]); + expect(t2.shape).toEqual([2, 2, 2]); + const expected = new Float32Array([1, 3, 2, 4, 11, 33, 22, 44]); + expect(t2.getValues()).toEqual(expected); + }); +}); + +describe('NDArrayMathCPU maxPool', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('1x1x1 in, 1x1 filter, 1 stride: [0] => [0]', () => { + const a = Array3D.new([1, 1, 1], [0]); + const result = math.maxPool(a, 1, 1, 0); + expect(result.getValues()).toBeCloseTo(0); + }); + + it('3x3x1 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, 9, 8]); + const result = math.maxPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([5, 6, 9, 9])); + }); + + it('3x3x1 in, 2x2 filter, 1 stride, propagates NaNs', () => { + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, NaN, 9]); + const result = math.maxPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([5, 6, NaN, NaN])); + }); + + it('3x3x2 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new( + [3, 3, 2], + [1, 99, 2, 88, 3, 77, 4, 66, 5, 55, 6, 44, 7, 33, 9, 22, 8, 11]); + const result = math.maxPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 2]); + expect(result.getValues()).toEqual(new Float32Array([ + 5, 99, 6, 88, 9, 66, 9, 55 + ])); + }); + + it('4x4x1 in, 2x2 filter, 2 stride', () => { + // Feed forward. + const a = Array3D.new( + [4, 4, 1], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); + const result = math.maxPool(a, 2, 2, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([5, 7, 13, 15])); + }); + + it('2x2x1 in, 2x2 filter, 2 stride, pad=1', () => { + // Feed forward. + const a = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const result = math.maxPool(a, 2, 2, 1); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([1, 2, 3, 4])); + }); +}); + +describe('NDArrayMathCPU minPool', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('1x1x1 in, 1x1 filter, 1 stride: [0] => [0]', () => { + const a = Array3D.new([1, 1, 1], [0]); + const result = math.minPool(a, 1, 1, 0); + expect(result.getValues()).toBeCloseTo(0); + }); + + it('3x3x1 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, 9, 8]); + const result = math.minPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([1, 2, 4, 5])); + }); + + it('3x3x1 in, 2x2 filter, 1 stride, propagates NaNs', () => { + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, NaN, 8]); + const result = math.minPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([1, 2, NaN, NaN])); + }); + + it('3x3x2 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new( + [3, 3, 2], + [1, 99, 2, 88, 3, 77, 4, 66, 5, 55, 6, 44, 7, 33, 9, 22, 8, 11]); + const result = math.minPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 2]); + expect(result.getValues()).toEqual(new Float32Array([ + 1, 55, 2, 44, 4, 22, 5, 11 + ])); + }); + + it('4x4x1 in, 2x2 filter, 2 stride', () => { + // Feed forward. + const a = Array3D.new( + [4, 4, 1], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); + const result = math.minPool(a, 2, 2, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([0, 2, 8, 10])); + }); + + it('2x2x1 in, 2x2 filter, 2 stride, pad=1', () => { + // Feed forward. + const a = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const result = math.minPool(a, 2, 2, 1); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([1, 2, 3, 4])); + }); +}); + +describe('NDArrayMathCPU avgPool', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('1x1x1 in, 1x1 filter, 1 stride: [0] => [0]', () => { + const a = Array3D.new([1, 1, 1], [0]); + const result = math.avgPool(a, 1, 1, 0); + expect(result.getValues()).toBeCloseTo(0); + }); + + it('3x3x1 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, 9, 8]); + const result = math.avgPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([3, 4, 6.25, 7])); + }); + + it('3x3x1 in, 2x2 filter, 1 stride, propagates NaNs', () => { + // Feed forward. + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, NaN, 8]); + const result = math.avgPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([3, 4, NaN, NaN])); + }); + + it('3x3x2 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new( + [3, 3, 2], + [1, 99, 2, 88, 3, 77, 4, 66, 5, 55, 6, 44, 7, 33, 9, 22, 8, 11]); + const result = math.avgPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 2]); + expect(result.getValues()).toEqual(new Float32Array([ + 3, 77, 4, 66, 6.25, 44, 7, 33 + ])); + }); + + it('4x4x1 in, 2x2 filter, 2 stride', () => { + // Feed forward. + const a = Array3D.new( + [4, 4, 1], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); + const result = math.avgPool(a, 2, 2, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([ + 2.5, 4.5, 10.5, 12.5 + ])); + }); + + it('2x2x1 in, 2x2 filter, 2 stride, pad=1', () => { + // Feed forward. + const a = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const result = math.avgPool(a, 2, 2, 1); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([0.25, 0.5, 0.75, 1])); + }); +}); + +describe('NDArrayMathCPU maxPoolBackprop', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('x=3x3x1, f=2, s=1, no duplicate max value, test #1', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, 8, 9]); + const expected = new Float32Array([0, 0, 0, 0, 1, 2, 0, 3, 4]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=3x3x1, f=2, s=1, no duplicate max value, test #2', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([3, 3, 1], [9, 5, 6, 6, 8, 4, 9, 5, 10]); + const expected = new Float32Array([1, 0, 0, 0, 2, 0, 3, 0, 4]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=3x3x1, f=2, s=1 duplicate max value, test 1', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([3, 3, 1], [0, 0, 0, 0, 5, 0, 0, 0, 0]); + const expected = new Float32Array([0, 0, 0, 0, 10, 0, 0, 0, 0]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=3x3x1, f=2, s=1 duplicate max value, test 2', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([3, 3, 1], [1, 3, 2, 1, 2, 1, 1, 1, 5]); + const expected = new Float32Array([0, 3, 0, 0, 3, 0, 0, 0, 4]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=4x4x1, f=2, s=2, test #1', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new( + [4, 4, 1], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); + const expected = + new Float32Array([0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 3, 0, 4]); + const dx = math.maxPoolBackprop(dy, x, 2, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=4x4x1, f=2, s=2, test #2', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new( + [4, 4, 1], [1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1]); + const expected = + new Float32Array([0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0]); + const dx = math.maxPoolBackprop(dy, x, 2, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=5x5x1, f=3, s=2 no duplicate max value', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([5, 5, 1], [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 + ]); + const expected = new Float32Array([ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4 + ]); + const dx = math.maxPoolBackprop(dy, x, 3, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=5x5x1, f=3, s=2 duplicate max value', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const x = Array3D.new([5, 5, 1], [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 24, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12 + ]); + const expected = new Float32Array([ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ]); + const dx = math.maxPoolBackprop(dy, x, 3, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); + + // Max pool backprop depth > 1. + it('x=3x3x2, f=2, s=1, no duplicate max value', () => { + // This test combines the first two 3x3x1 tests with no duplicates to + // make depth=2, + // dy is slightly modified to show the difference. + const dy = Array3D.new([2, 2, 2], [1, 44, 2, 33, 3, 22, 4, 11]); + const x = Array3D.new( + [3, 3, 2], + [1, 99, 2, 55, 3, 66, 4, 66, 5, 88, 6, 44, 7, 99, 8, 55, 9, 100]); + const expected = new Float32Array( + [0, 44, 0, 0, 0, 0, 0, 0, 1, 33, 2, 0, 0, 22, 3, 0, 4, 11]); + + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=3x3x2, f=2, s=1, duplicate max value', () => { + // This test combines the first two 3x3x1 tests with duplicates to + // make depth=2, + // dy is slightly modified to show the difference. + const dy = Array3D.new([2, 2, 2], [1, 44, 2, 33, 3, 22, 4, 11]); + const x = Array3D.new( + [3, 3, 2], [0, 1, 0, 3, 0, 2, 0, 1, 5, 2, 0, 1, 0, 1, 0, 1, 0, 5]); + const expected = new Float32Array( + [0, 0, 0, 77, 0, 0, 0, 0, 10, 22, 0, 0, 0, 0, 0, 0, 0, 11]); + + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=4x4x2, f=2, s=1', () => { + // This test combines the first two 4x4x1 tests with duplicates to make + // depth=2, + // dy is slightly modified to show the difference. + const dy = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const x = Array3D.new([4, 4, 2], [ + 0, 1, 1, 2, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, + 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 2, 14, 2, 15, 1 + ]); + const expected = new Float32Array([ + 0, 0, 0, 11, 0, 22, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 33, 0, 44, 4, 0 + ]); + const dx = math.maxPoolBackprop(dy, x, 2, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); + + it('x=5x5x2, f=3, s=2 no duplicate max value', () => { + // This test combines the first two 5x5x1 tests with duplicates to make + // depth=2, + // dy is slightly modified to show the difference. + const dy = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const x = Array3D.new([5, 5, 2], [ + 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, + 8, 9, 9, 10, 10, 11, 11, 12, 24, 13, 13, 14, 14, 15, 15, 16, 16, + 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 12 + ]); + const expected = new Float32Array([ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 110, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0 + ]); + const dx = math.maxPoolBackprop(dy, x, 3, 2, 0); + expect(dx.getValues()).toEqual(expected); + }); +}); + +describe('NDArrayMathCPU resizeBilinear', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('simple alignCorners=false', () => { + const input = Array3D.new([2, 2, 1], [2, 2, 4, 4]); + const output = math.resizeBilinear3D(input, [3, 3], false); + + test_util.expectArraysClose( + output.getValues(), + new Float32Array([2, 2, 2, 10 / 3, 10 / 3, 10 / 3, 4, 4, 4]), 1e-4); + }); + + it('simple alignCorners=true', () => { + const input = Array3D.new([2, 2, 1], [2, 2, 4, 4]); + const output = math.resizeBilinear3D(input, [3, 3], true); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([2, 2, 2, 3, 3, 3, 4, 4, 4]), + 1e-4); + }); + + it('matches tensorflow w/ random numbers alignCorners=false', () => { + const input = Array3D.new([2, 3, 2], [ + 1.19074044, 0.91373104, 2.01611669, -0.52270832, 0.38725395, 1.30809779, + 0.61835143, 3.49600659, 2.09230986, 0.56473997, 0.03823943, 1.19864896 + ]); + const output = math.resizeBilinear3D(input, [4, 5], false); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([ + 1.19074047, 0.91373104, 1.68596613, 0.05186744, 1.69034398, + -0.15654698, 0.7130264, 0.94193673, 0.38725394, 1.30809784, + 0.9045459, 2.20486879, 1.59434628, 0.89455694, 1.68591988, + 0.26748738, 0.58103991, 1.00690198, 0.21274668, 1.25337338, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893 + ]), + 1e-4); + }); + + it('matches tensorflow w/ random numbers alignCorners=true', () => { + const input = Array3D.new([2, 3, 2], [ + 1.56324531, 2.13817752, 1.44398421, 1.07632684, 0.59306785, -0.36970865, + 1.62451879, 1.8367334, 1.13944798, 2.01993218, 2.01919952, 2.67524054 + ]); + const output = math.resizeBilinear3D(input, [4, 5], true); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([ + 1.5632453, 2.13817763, 1.50361478, 1.60725224, 1.44398427, + 1.07632685, 1.01852608, 0.35330909, 0.59306782, -0.36970866, + 1.58366978, 2.03769612, 1.46307099, 1.71427906, 1.3424722, + 1.39086199, 1.20545864, 1.01806819, 1.06844509, 0.6452744, + 1.60409427, 1.93721485, 1.42252707, 1.82130599, 1.24096, + 1.70539713, 1.3923912, 1.68282723, 1.54382229, 1.66025746, + 1.62451875, 1.83673346, 1.38198328, 1.92833281, 1.13944793, + 2.01993227, 1.57932377, 2.34758639, 2.01919961, 2.67524052 + ]), + 1e-4); + }); +}); + +describe('NDArrayMathCPU batchNorm', () => { + let math: NDArrayMathCPU; + beforeEach(() => { + math = new NDArrayMathCPU(); + }); + + it('simple batchnorm, no offset or scale, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, undefined, undefined); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + (x.get(0, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(0, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon), + (x.get(1, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(1, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-6); + }); + + it('simple batchnorm, no offset, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const scale = Array1D.new([4, 5]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, undefined); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + (x.get(0, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(0, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon), + (x.get(1, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(1, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-6); + }); + + it('simple batchnorm, no scale, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const offset = Array1D.new([4, 5]); + + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, undefined, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + offset.get(0) + + (x.get(0, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(0, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon), + offset.get(0) + + (x.get(1, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(1, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-6); + }); + + it('simple batchnorm, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const offset = Array1D.new([3, 4]); + const scale = Array1D.new([4, 5]); + + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + offset.get(0) + + (x.get(0, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(0, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon), + offset.get(0) + + (x.get(1, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(1, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-6); + }); + + it('batchnorm matches tensorflow, 2x3x3', () => { + const x = + Array3D.new([2, 3, 3], new Float32Array([ + 0.49955603, 0.04158615, -1.09440524, 2.03854165, + -0.61578344, 2.87533573, 1.18105987, 0.807462, 1.87888837, + 2.26563962, -0.37040935, 1.35848753, -0.75347094, + 0.15683117, 0.91925946, 0.34121279, 0.92717143, 1.89683965 + ])); + const mean = Array1D.new([0.39745062, -0.48062894, 0.4847822]); + const variance = Array1D.new([0.32375343, 0.67117643, 1.08334653]); + const offset = Array1D.new([0.69398749, -1.29056387, 0.9429723]); + const scale = Array1D.new([-0.5607271, 0.9878457, 0.25181573]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + 0.59352049, -0.66135202, 0.5610874, -0.92077015, -1.45341019, + 1.52106473, -0.07704776, 0.26144429, 1.28010017, -1.14422404, + -1.15776136, 1.15425493, 1.82644104, -0.52249442, 1.04803919, + 0.74932291, 0.40568101, 1.2844412 + ]), + 1e-5); + }); +}); diff --git a/src/math/math_gpu.ts b/src/math/math_gpu.ts new file mode 100644 index 0000000000..f13ab81003 --- /dev/null +++ b/src/math/math_gpu.ts @@ -0,0 +1,1303 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; + +import * as concat3d_util from './concat3d_util'; +import * as conv_util from './conv_util'; +import {MatrixOrientation, NDArrayMath} from './math'; +import * as ndarray from './ndarray'; +import {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray'; +import * as addscaledmat_gpu from './webgl/addscaledmat_gpu'; +import * as addsubmuldiv_gpu from './webgl/addsubmuldiv_gpu'; +import {OperandType} from './webgl/addsubmuldiv_gpu'; +import * as argmaxequals_gpu from './webgl/argmaxequals_gpu'; +import * as argminmax_gpu from './webgl/argminmax_gpu'; +import * as avg_pool_gpu from './webgl/avg_pool_gpu'; +import * as batchnorm_gpu from './webgl/batchnorm_gpu'; +import * as concat3d_gpu from './webgl/concat3d_gpu'; +import * as conv_backprop_gpu from './webgl/conv_backprop_gpu'; +import * as conv_gpu from './webgl/conv_gpu'; +import * as copy_gpu from './webgl/copy_gpu'; +import * as exp_gpu from './webgl/exp_gpu'; +import {GPGPUContext} from './webgl/gpgpu_context'; +import * as gpgpu_util from './webgl/gpgpu_util'; +import * as log_gpu from './webgl/log_gpu'; +import * as logsumexp_gpu from './webgl/logsumexp_gpu'; +import * as max_pool_backprop_gpu from './webgl/max_pool_backprop_gpu'; +import * as max_pool_gpu from './webgl/max_pool_gpu'; +import * as min_pool_gpu from './webgl/min_pool_gpu'; +import * as minmax_gpu from './webgl/minmax_gpu'; +import * as mulmat_gpu from './webgl/mulmat_gpu'; +import * as neg_gpu from './webgl/neg_gpu'; +import * as pool_gpu from './webgl/pool_gpu'; +import * as reducesum_gpu from './webgl/reducesum_gpu'; +import * as relu_gpu from './webgl/relu_gpu'; +import * as reshape_gpu from './webgl/reshape_gpu'; +import * as resize_bilinear_gpu from './webgl/resize_bilinear_gpu'; +import * as shader_compiler from './webgl/shader_compiler'; +import * as sigmoid_gpu from './webgl/sigmoid_gpu'; +import * as step_gpu from './webgl/step_gpu'; +import {TextureManager} from './webgl/texture_manager'; +import * as trig_gpu from './webgl/trig_gpu'; +import * as webgl_util from './webgl/webgl_util'; + +const ARGMAX_PROG = 'argmax'; +const ARGMAX_EQUALS_PROG = 'argmaxequals'; +const ARGMIN_PROG = 'argmin'; + +const BATCHNORM_PROG = 'batchnorm'; + +const COPY_PROG = 'copy'; +const CONCAT_PROG = 'concat'; + +// Matrix algebra. +const ADD_SCALED_MAT_PROG = 'addscaledmat'; +const MATMUL_PROG = 'matmul'; + +// Element-wise ops. +const RELU_PROG = 'relu'; +const TANH_PROG = 'tanh'; +const SIN_PROG = 'sin'; +const SIGMOID_PROG = 'sigmoid'; +const MAX_PROG = 'max'; +const MIN_PROG = 'min'; +const NEG_PROG = 'neg'; +const EXP_PROG = 'exp'; +const LOG_PROG = 'log'; +const SUM_PROG = 'sum'; +const STEP_PROG = 'step'; +const LOGSUMEXP_PROG = 'logsumexp'; +const RESHAPE_PROG = 'reshape'; +const ADD_SUM_MUL_DIV_PROG = 'addsummuldiv'; + +// Convolution. +const CONV2D_PROG = 'conv'; +const CONV2D_TRANSPOSE_PROG = 'conv_transpose'; +const CONV2D_DERW_PROG = 'conv_derw'; +const CONV2D_DERB_PROG = 'conv_derb'; +const MAX_POOL_PROG = 'maxpool'; +const MAX_POOL_POSITIONS_PROG = 'maxpool_posn'; +const MAX_POOL_BACKPROP_PROG = 'maxpool_backprop'; +const MIN_POOL_PROG = 'minpool'; +const AVG_POOL_PROG = 'avgpool'; + +const RESIZE_BILINEAR_PROG = 'resizebilin'; + +function makeCopyProgramName( + sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number], + destSizeRowCol: [number, number]): string { + const shapeName = `${sourceShapeRowCol[0]}_${sourceShapeRowCol[1]}`; + const srcSizeName = `${sourceSizeRowCol[0]}_${sourceSizeRowCol[1]}`; + const dstSizeName = `${destSizeRowCol[0]}_${destSizeRowCol[1]}`; + return `${COPY_PROG}_${shapeName}_${srcSizeName}_${dstSizeName}`; +} + +export class NDArrayMathGPU extends NDArrayMath { + private gpgpu: GPGPUContext; + private textureManager: TextureManager; + private programCache: {[key: string]: WebGLProgram} = {}; + private gpgpuCreatedLocally: boolean; + + constructor(gpgpu?: GPGPUContext, safeMode = true) { + super(safeMode); + if (gpgpu == null) { + const gl = gpgpu_util.createWebGLContext(); + this.gpgpu = new GPGPUContext(gl); + this.gpgpuCreatedLocally = true; + } else { + this.gpgpu = gpgpu; + this.gpgpuCreatedLocally = false; + } + + this.textureManager = new TextureManager(this.gpgpu); + + ndarray.initializeGPU(this.gpgpu, this.textureManager); + } + + getGPGPUContext(): GPGPUContext { + return this.gpgpu; + } + + protected cloneInternal(ndarray: T): T { + const textureShapeRC = ndarray.getTextureShapeRC(); + const program = this.getAndSaveProgram( + makeCopyProgramName(textureShapeRC, textureShapeRC, textureShapeRC), + () => copy_gpu.getFragmentShaderSource( + textureShapeRC, textureShapeRC, textureShapeRC)); + + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + copy_gpu.copy( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC, [0, 0], + textureShapeRC, resultTexture, textureShapeRC, [0, 0], textureShapeRC); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected reshapeInternal( + ndarray: T1, newShape: number[]): T2 { + let newTexShape: [number, number]; + + switch (newShape.length) { + case 0: + newTexShape = [1, 1]; + break; + case 1: + newTexShape = [newShape[0], 1]; + break; + case 2: + newTexShape = [newShape[0], newShape[1]]; + break; + case 3: + newTexShape = [newShape[0], newShape[1] * newShape[2]]; + break; + default: + throw Error( + `Reshapes into ${newShape.length}-dim ndarray is not yet ` + + `supported on GPU`); + } + + const actualTexShape = ndarray.getTextureShapeRC(newTexShape); + let clonedArray: T1; + if (!util.arraysEqual(actualTexShape, newTexShape)) { + clonedArray = this.reshapeTexture(ndarray, newTexShape); + } else { + clonedArray = this.cloneInternal(ndarray); + } + return clonedArray.reshape(newShape); + } + + protected slice2DInternal( + input: Array2D, beginRowCol: [number, number], + sizeRowCol: [number, number]): Array2D { + const result = NDArray.make(sizeRowCol, { + texture: this.textureManager.acquireTexture(sizeRowCol), + textureShapeRC: sizeRowCol + }); + this.copy2DInternal( + input, beginRowCol, sizeRowCol, result, [0, 0], sizeRowCol); + return result; + } + + protected copy2DInternal( + source: Array2D, sourceBeginRowCol: [number, number], + sourceSizeRowCol: [number, number], dest: Array2D, + destBeginRowCol: [number, number], + destSizeRowCol: [number, number]): void { + const sourceShapeRC = source.getTextureShapeRC(); + const destShapeRC = dest.getTextureShapeRC(); + const program = this.getAndSaveProgram( + makeCopyProgramName(sourceShapeRC, sourceSizeRowCol, destSizeRowCol), + () => copy_gpu.getFragmentShaderSource( + sourceShapeRC, sourceSizeRowCol, destSizeRowCol)); + + copy_gpu.copy( + this.gpgpu, program, source.getTexture(), sourceShapeRC, + sourceBeginRowCol, sourceSizeRowCol, dest.getTexture(), destShapeRC, + destBeginRowCol, destSizeRowCol); + } + + protected concat3DInternal(x1: Array3D, x2: Array3D, axis: number): Array3D { + const x1TexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(x1.shape); + const x2TexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(x2.shape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualX1TexShape = x1.getTextureShapeRC(x1TexShapeRC); + let cleanupX1 = false; + if (!util.arraysEqual(actualX1TexShape, x1TexShapeRC)) { + x1 = this.reshapeTexture(x1, x1TexShapeRC); + cleanupX1 = true; + } + const actualX2TexShape = x2.getTextureShapeRC(x2TexShapeRC); + let cleanupX2 = false; + if (!util.arraysEqual(actualX2TexShape, x2TexShapeRC)) { + x2 = this.reshapeTexture(x2, x2TexShapeRC); + cleanupX2 = true; + } + + const resultShapeRCD = + concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis); + + const program = this.getAndSaveProgram( + `${CONCAT_PROG}_${x1.shape}_${x2.shape}_${axis}`, + () => concat3d_gpu.getFragmentShaderSource( + x1.shape, x2.shape, resultShapeRCD, axis)); + + const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + concat3d_gpu.concat3D( + this.gpgpu, program, x1.getTexture(), x2.getTexture(), resultTex, + resultTexShape); + + if (cleanupX1) { + x1.dispose(); + } + + if (cleanupX2) { + x2.dispose(); + } + + return NDArray.make( + resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape}); + } + + protected scalarPlusArrayInternal(c: Scalar, a: T): T { + return this.addSubMulDiv( + c, a, a.shape, OperandType.SCALAR, '+', OperandType.MATRIX) as T; + } + + protected arrayMinusScalarInternal(a: T, c: Scalar): T { + return this.addSubMulDiv( + a, c, a.shape, OperandType.MATRIX, '-', OperandType.SCALAR) as T; + } + + protected scalarMinusArrayInternal(c: Scalar, a: T): T { + return this.addSubMulDiv( + c, a, a.shape, OperandType.SCALAR, '-', OperandType.MATRIX) as T; + } + + protected scaledArrayAddInternal( + c1: Scalar, a: T, c2: Scalar, b: T) { + let cleanupB = false; + if (!this.doGPUShapesMatch(a, b)) { + b = this.reshapeTexture(b, a.getTextureShapeRC()); + cleanupB = true; + } + + const program = this.getAndSaveProgram( + ADD_SCALED_MAT_PROG, () => addscaledmat_gpu.getFragmentShaderSource()); + + const textureShapeRC = a.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + addscaledmat_gpu.addScaledMatrices( + this.gpgpu, program, a.getTexture(), b.getTexture(), textureShapeRC[0], + textureShapeRC[1], c1.getTexture(), c2.getTexture(), resultTexture); + + if (cleanupB) { + b.dispose(); + } + // Bring the result back to the original shape. + return NDArray.make(a.shape, {texture: resultTexture, textureShapeRC}); + } + + protected scalarTimesArrayInternal(c: Scalar, a: T): T { + return this.addSubMulDiv( + c, a, a.shape, OperandType.SCALAR, '*', OperandType.MATRIX) as T; + } + + protected negInternal(a: T): T { + const program = this.getAndSaveProgram( + NEG_PROG, () => neg_gpu.getFragmentShaderSource()); + + const textureShapeRC = a.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + neg_gpu.neg( + this.gpgpu, program, a.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make(a.shape, {texture: resultTexture, textureShapeRC}); + } + + private reshapeTexture(a: T, newTextureShape: [ + number, number + ]): T { + const aTexShape = a.getTextureShapeRC(); + + const program = this.getAndSaveProgram( + RESHAPE_PROG, () => reshape_gpu.getFragmentShaderSource()); + + const resultTexture = this.textureManager.acquireTexture(newTextureShape); + reshape_gpu.reshape( + this.gpgpu, program, a.getTexture(), aTexShape[0], aTexShape[1], + resultTexture, newTextureShape[0], newTextureShape[1]); + + return NDArray.make( + a.shape, {texture: resultTexture, textureShapeRC: newTextureShape}); + } + + protected matMulInternal( + a: Array2D, b: Array2D, aOrientation: MatrixOrientation, + bOrientation: MatrixOrientation): Array2D { + const sharedDim = + (aOrientation === MatrixOrientation.REGULAR) ? a.shape[1] : a.shape[0]; + const outerShapeA = + (aOrientation === MatrixOrientation.REGULAR) ? a.shape[0] : a.shape[1]; + const outerShapeB = + (bOrientation === MatrixOrientation.REGULAR) ? b.shape[1] : b.shape[0]; + const outShape: [number, number] = [outerShapeA, outerShapeB]; + const outTexShape = + webgl_util.getTextureShapeFromLogicalShape(this.gpgpu.gl, outShape); + const outTexture = this.textureManager.acquireTexture(outTexShape); + const out = new Array2D( + outShape, {texture: outTexture, textureShapeRC: outTexShape}); + + const key = shader_compiler.makeShaderKey([a, b], out); + const program = this.getAndSaveProgram( + `${MATMUL_PROG}_${key}_${aOrientation}_${bOrientation}`, + () => mulmat_gpu.getFragmentShader( + a, b, out, aOrientation, bOrientation)); + + mulmat_gpu.multiplyMatrix( + this.gpgpu, program, a.getTexture(), b.getTexture(), outTexture, + outTexShape); + + return out; + } + + protected elementWiseMulInternal(a: T, b: T): T { + return this.addSubMulDiv( + a, b, a.shape, OperandType.MATRIX, '*', OperandType.MATRIX) as T; + } + + protected elementWiseMulBroadcastInternal(a: Array2D, b: Array2D): Array2D { + throw new Error('Not yet implemented!'); + } + + protected batchNormalization3DInternal( + x: Array3D, mean: Array3D|Array1D, variance: Array3D|Array1D, + varianceEpsilon: number, scale?: Array3D|Array1D, + offset?: Array3D|Array1D): Array3D { + const xTexShape = x.getTextureShapeRC(); + + let cleanupMean = false; + const preferredMeanTexShape: [number, number] = + mean.rank === 1 ? [1, mean.size] : xTexShape; + let meanTexShape = mean.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(meanTexShape, preferredMeanTexShape)) { + mean = this.reshapeTexture(mean, preferredMeanTexShape); + meanTexShape = preferredMeanTexShape; + cleanupMean = true; + } + + let cleanupVariance = false; + const preferredVarianceTexShape: [number, number] = + variance.rank === 1 ? [1, variance.size] : xTexShape; + let varianceTexShape = variance.getTextureShapeRC(preferredMeanTexShape); + if (!util.arraysEqual(varianceTexShape, preferredVarianceTexShape)) { + variance = this.reshapeTexture(variance, preferredVarianceTexShape); + varianceTexShape = preferredVarianceTexShape; + cleanupVariance = true; + } + + let scaleTexShape: [number, number]|null = null; + let cleanupScale = false; + if (scale != null) { + const preferredScaleTexShape: [number, number] = + scale.rank === 1 ? [1, scale.size] : xTexShape; + + scaleTexShape = scale.getTextureShapeRC(preferredScaleTexShape); + if (!util.arraysEqual(scaleTexShape, preferredScaleTexShape)) { + scale = this.reshapeTexture(scale, preferredScaleTexShape); + scaleTexShape = preferredScaleTexShape; + cleanupScale = true; + } + } + + let offsetTexShape: [number, number]|null = null; + let cleanupOffset = false; + if (offset != null) { + const preferredOffsetTexShape: [number, number] = + offset.rank === 1 ? [1, offset.size] : xTexShape; + + offsetTexShape = offset.getTextureShapeRC(preferredOffsetTexShape); + if (!util.arraysEqual(offsetTexShape, preferredOffsetTexShape)) { + offset = this.reshapeTexture(offset, preferredOffsetTexShape); + offsetTexShape = preferredOffsetTexShape; + cleanupOffset = true; + } + } + + const resultTexShape: [number, number] = x.getTextureShapeRC(); + + const program = this.getAndSaveProgram( + `${BATCHNORM_PROG}_${xTexShape}_${meanTexShape}_${varianceTexShape}_` + + `${scaleTexShape!}_${offsetTexShape!}_${varianceEpsilon}`, + () => batchnorm_gpu.getFragmentShaderSource( + xTexShape, meanTexShape, varianceTexShape, offsetTexShape, + scaleTexShape, varianceEpsilon)); + + const resultTexture = this.textureManager.acquireTexture(resultTexShape); + + batchnorm_gpu.batchNormalization( + this.gpgpu, program, x.getTexture(), xTexShape, mean.getTexture(), + meanTexShape, variance.getTexture(), varianceTexShape, + offset != null ? offset.getTexture() : null, + offset != null ? offsetTexShape : null, + scale != null ? scale.getTexture() : null, + scale != null ? scaleTexShape : null, resultTexture, resultTexShape); + + if (cleanupMean) { + mean.dispose(); + } + if (cleanupVariance) { + variance.dispose(); + } + if (cleanupScale) { + scale!.dispose(); + } + if (cleanupOffset) { + offset!.dispose(); + } + + return NDArray.make( + x.shape, {texture: resultTexture, textureShapeRC: resultTexShape}); + } + + protected switchDimInternal(a: T, newDim: number[]): T { + throw new Error('Not yet implemented!'); + } + + protected sumInternal(ndarray: NDArray): Scalar { + const textureShapeRC = ndarray.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${SUM_PROG}_${numRows}_${numColumns}`, + () => reducesum_gpu.getFragmentShaderSource(numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + reducesum_gpu.reduceSum( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + resultTexture); + + return new Scalar({texture: resultTexture}); + } + + protected argMinInternal(ndarray: NDArray): Scalar { + const textureShapeRC = ndarray.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${ARGMIN_PROG}_${numRows}_${numColumns}`, + () => argminmax_gpu.getArgMinFragmentShaderSource(numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + argminmax_gpu.argMinMax( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + resultTexture); + + return new Scalar({texture: resultTexture}); + } + + protected argMaxInternal(ndarray: NDArray): Scalar { + const textureShapeRC = ndarray.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${ARGMAX_PROG}_${numRows}_${numColumns}`, + () => argminmax_gpu.getArgMaxFragmentShaderSource(numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + argminmax_gpu.argMinMax( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + resultTexture); + + return new Scalar({texture: resultTexture}); + } + + protected argMaxEqualsInternal(x1: NDArray, x2: NDArray): Scalar { + // If the texture shapes doesn't match, do a physical reshape so they do. + const actualX1TexShape = x1.getTextureShapeRC(); + const actualX2TexShape = x2.getTextureShapeRC(); + let cleanupX2 = false; + if (!util.arraysEqual(actualX1TexShape, actualX2TexShape)) { + x2 = this.reshapeTexture(x2, actualX1TexShape); + cleanupX2 = true; + } + + const textureShapeRC = x1.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${ARGMAX_EQUALS_PROG}_${numRows}_${numColumns}`, + () => argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource( + numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + argmaxequals_gpu.argMaxEquals( + this.gpgpu, program, x1.getTexture(), x2.getTexture(), numRows, + numColumns, resultTexture); + + if (cleanupX2) { + x2.dispose(); + } + + return new Scalar({texture: resultTexture}); + } + + protected topKInternal(ndarray: NDArray, k: number): + {values: Array1D, indices: Array1D} { + throw new Error('topK GPU not yet implemented!'); + } + + protected minInternal(ndarray: NDArray): Scalar { + const textureShapeRC = ndarray.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${MIN_PROG}_${numRows}_${numColumns}`, + () => minmax_gpu.getMinFragmentShaderSource(numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + minmax_gpu.minMax( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + resultTexture); + + return new Scalar({texture: resultTexture}); + } + + protected maxInternal(ndarray: NDArray): Scalar { + const textureShapeRC = ndarray.getTextureShapeRC(); + const [numRows, numColumns] = textureShapeRC; + + const program = this.getAndSaveProgram( + `${MAX_PROG}_${numRows}_${numColumns}`, + () => minmax_gpu.getMaxFragmentShaderSource(numRows, numColumns)); + + const resultTexture = this.textureManager.acquireTexture([1, 1]); + + minmax_gpu.minMax( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + resultTexture); + + return new Scalar({texture: resultTexture}); + } + + protected divideInternal(a: T, b: T): T { + return this.addSubMulDiv( + a, b, a.shape, OperandType.MATRIX, '/', OperandType.MATRIX) as T; + } + + protected scalarDividedByArrayInternal(c: Scalar, a: T): + T { + return this.addSubMulDiv( + c, a, a.shape, OperandType.SCALAR, '/', OperandType.MATRIX) as T; + } + + protected arrayDividedByScalarInternal(a: T, c: Scalar): + T { + return this.addSubMulDiv( + a, c, a.shape, OperandType.MATRIX, '/', OperandType.SCALAR) as T; + } + + protected addInternal(a: T, b: T): T { + return this.addSubMulDiv( + a, b, a.shape, OperandType.MATRIX, '+', OperandType.MATRIX) as T; + } + + protected subInternal(a: T, b: T): T { + return this.addSubMulDiv( + a, b, a.shape, OperandType.MATRIX, '-', OperandType.MATRIX) as T; + } + + protected logSumExpInternal(ndarray: NDArray): Scalar { + const [numRows, numColumns] = ndarray.getTextureShapeRC(); + + const program = this.getAndSaveProgram( + `${LOGSUMEXP_PROG}_${numRows}_${numColumns}`, + () => logsumexp_gpu.getFragmentShaderSource(numRows, numColumns)); + + const result = + new Scalar({texture: this.textureManager.acquireTexture([1, 1])}); + + reducesum_gpu.reduceSum( + this.gpgpu, program, ndarray.getTexture(), numRows, numColumns, + result.getTexture()); + + return result; + } + + protected expInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + EXP_PROG, () => exp_gpu.getFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + exp_gpu.exp( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected logInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + LOG_PROG, () => log_gpu.getFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + log_gpu.log( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected reluInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + RELU_PROG, () => relu_gpu.getFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + relu_gpu.relu( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected sigmoidInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + SIGMOID_PROG, () => sigmoid_gpu.getSigmoidFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + sigmoid_gpu.sigmoid( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected tanhInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + TANH_PROG, () => trig_gpu.getTanhFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + trig_gpu.tanh( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected sinInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + SIN_PROG, () => trig_gpu.getSinFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + trig_gpu.sin( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected stepInternal(ndarray: T): T { + const program = this.getAndSaveProgram( + STEP_PROG, () => step_gpu.getFragmentShaderSource()); + + const textureShapeRC = ndarray.getTextureShapeRC(); + const resultTexture = this.textureManager.acquireTexture(textureShapeRC); + + step_gpu.step( + this.gpgpu, program, ndarray.getTexture(), textureShapeRC[0], + textureShapeRC[1], resultTexture); + + return NDArray.make( + ndarray.shape, {texture: resultTexture, textureShapeRC}); + } + + protected conv2dInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, stride: number, + zeroPad: number): Array3D { + const fieldSize = weights.shape[0]; + const inputDepth = weights.shape[2]; + const outputDepth = weights.shape[3]; + const progKey = [ + CONV2D_PROG, x.shape, outputDepth, fieldSize, stride, biases != null + ].join('_'); + const program = this.getAndSaveProgram(progKey, () => { + return conv_gpu.getFragmentShaderSource( + x.shape, outputDepth, fieldSize, stride, zeroPad, biases != null); + }); + + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + const wTexShape = + conv_util.computeWeightsTexShape(inputDepth, outputDepth, fieldSize); + const biasTexShape = conv_util.computeBiasesTexShape(outputDepth); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualXTexShape = x.getTextureShapeRC(xTexShape); + let cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + let cleanupW = false; + const actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + + let cleanupB = false; + if (biases != null) { + const actualBTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + + const resultShape = conv_util.computeOutputShape3D( + x.shape, fieldSize, outputDepth, stride, zeroPad); + const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + conv_gpu.convolve( + this.gpgpu, program, x.getTexture(), weights.getTexture(), + biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB && biases != null) { + biases.dispose(); + } + + return NDArray.make( + resultShape, {texture: resultTex, textureShapeRC: resultTexShape}); + } + + protected conv2dBackPropInternal( + x: Array3D, dy: Array3D, weights: Array4D, stride: number, + pad: number): {dx: Array3D, dw: Array4D, db: Array1D} { + const fSize = weights.shape[0]; + const inputDepth = weights.shape[2]; + const outputDepth = weights.shape[3]; + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + const wTexShape = + conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + const yTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + let cleanupX = false; + const actualXTexShape = x.getTextureShapeRC(xTexShape); + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + let cleanupW = false; + const actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + + let cleanupY = false; + const actualYTexShape = dy.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dy = this.reshapeTexture(dy, yTexShape); + cleanupY = true; + } + + const dw = this.conv2dDerWeights(x, dy, fSize, stride, pad); + const db = this.conv2dDerBias(dy); + const dx = this.conv2dTransposeInternal( + dy, weights, null /** biases */, stride, pad); + + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupY) { + dy.dispose(); + } + return {dx, db, dw}; + } + + protected conv2dTransposeInternal( + x: Array3D, weights: Array4D, biases: Array1D|null, origStride: number, + origPad: number): Array3D { + const origInputDepth = weights.shape[2]; + const origOutputDepth = weights.shape[3]; + const fieldSize = weights.shape[0]; + + const progKey = [ + CONV2D_TRANSPOSE_PROG, x.shape, fieldSize, origInputDepth, origStride, + origPad, biases != null + ].join('_'); + const program = this.getAndSaveProgram(progKey, () => { + return conv_backprop_gpu.getFragmentShaderConvTransposeSource( + x.shape, fieldSize, origInputDepth, origStride, origPad, + biases != null); + }); + + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + const wTexShape = conv_util.computeWeightsTexShape( + origInputDepth, origOutputDepth, fieldSize); + const biasTexShape = conv_util.computeBiasesTexShape(origInputDepth); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualXTexShape = x.getTextureShapeRC(xTexShape); + let cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + let cleanupW = false; + const actualWTexShape = weights.getTextureShapeRC(wTexShape); + if (!util.arraysEqual(actualWTexShape, wTexShape)) { + weights = this.reshapeTexture(weights, wTexShape); + cleanupW = true; + } + + let cleanupB = false; + if (biases != null) { + const actualBiasTexShape = biases.getTextureShapeRC(biasTexShape); + if (!util.arraysEqual(actualBiasTexShape, biasTexShape)) { + biases = this.reshapeTexture(biases, biasTexShape); + cleanupB = true; + } + } + + // Figure out the output shape by dilating the input. + const dilatedRC = + conv_util.computeDilatedRC([x.shape[0], x.shape[1]], origStride); + const pad = fieldSize - 1 - origPad; + const resultShape = conv_util.computeOutputShape3D( + [dilatedRC[0], dilatedRC[1], origOutputDepth], fieldSize, + origInputDepth, 1, pad); + const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + conv_backprop_gpu.convTranspose( + this.gpgpu, program, x.getTexture(), weights.getTexture(), + biases != null ? biases.getTexture() : null, resultTex, resultTexShape); + + if (cleanupX) { + x.dispose(); + } + if (cleanupW) { + weights.dispose(); + } + if (cleanupB) { + biases!.dispose(); + } + + return NDArray.make( + resultShape, {texture: resultTex, textureShapeRC: resultTexShape}); + } + + conv2dDerWeights( + x: Array3D, dY: Array3D, fSize: number, stride: number, + zeroPad: number): Array4D { + const inputDepth = x.shape[2]; + const outputDepth = dY.shape[2]; + const progKey = [ + CONV2D_DERW_PROG, x.shape, fSize, outputDepth, stride, zeroPad + ].join('_'); + const program = this.getAndSaveProgram(progKey, () => { + return conv_backprop_gpu.getFragmentShaderDerWeightsSource( + x.shape, fSize, outputDepth, stride, zeroPad); + }); + + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + const yShape = conv_util.computeOutputShape3D( + x.shape, fSize, outputDepth, stride, zeroPad); + const yTexShape = conv_util.computeTexShapeFrom3D(yShape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualXTexShape = x.getTextureShapeRC(xTexShape); + let cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + let cleanupY = false; + const actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + + const resultTexShape = + conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + conv_backprop_gpu.derWeights( + this.gpgpu, program, x.getTexture(), dY.getTexture(), resultTex, + resultTexShape); + + if (cleanupX) { + x.dispose(); + } + if (cleanupY) { + dY.dispose(); + } + + const weightsShape = + conv_util.computeWeightsShape4D(inputDepth, outputDepth, fSize); + return NDArray.make( + weightsShape, {texture: resultTex, textureShapeRC: resultTexShape}); + } + + conv2dDerBias(dY: Array3D): Array1D { + const outputDepth = dY.shape[2]; + const progKey = [CONV2D_DERB_PROG, dY.shape].join('_'); + const program = this.getAndSaveProgram(progKey, () => { + return conv_backprop_gpu.getFragmentShaderDerBiasSource(dY.shape); + }); + const yTexShape = conv_util.computeTexShapeFrom3D(dY.shape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + let cleanupY = false; + const actualYTexShape = dY.getTextureShapeRC(yTexShape); + if (!util.arraysEqual(actualYTexShape, yTexShape)) { + dY = this.reshapeTexture(dY, yTexShape); + cleanupY = true; + } + + const resultTexShape = conv_util.computeBiasesTexShape(outputDepth); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + conv_backprop_gpu.derBias( + this.gpgpu, program, dY.getTexture(), resultTex, resultTexShape); + + if (cleanupY) { + dY.dispose(); + } + + return NDArray.make( + [outputDepth], {texture: resultTex, textureShapeRC: resultTexShape}); + } + + private pool( + program: WebGLProgram, x: Array3D, fSize: number, stride: number, + pad: number): Array3D { + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualXTexShape = x.getTextureShapeRC(xTexShape); + let cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + const resultShape = + conv_util.computeOutputShape3D(x.shape, fSize, x.shape[2], stride, pad); + const resultTexShape = conv_util.computeTexShapeFrom3D(resultShape); + const poolResultTex = this.textureManager.acquireTexture(resultTexShape); + + pool_gpu.poolCommon( + this.gpgpu, program, x.getTexture(), poolResultTex, resultTexShape); + + if (cleanupX) { + x.dispose(); + } + + return NDArray.make( + resultShape, {texture: poolResultTex, textureShapeRC: resultTexShape}); + } + + protected maxPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + const maxPoolProgKey = + [MAX_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + const maxPoolProgram = this.getAndSaveProgram(maxPoolProgKey, () => { + return max_pool_gpu.getFragmentShaderMaxPoolSource( + x.shape, fSize, stride, pad); + }); + + return this.pool(maxPoolProgram, x, fSize, stride, pad); + } + + protected minPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + const minPoolProgKey = + [MIN_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + const minPoolProgram = this.getAndSaveProgram(minPoolProgKey, () => { + return min_pool_gpu.getFragmentShaderMinPoolSource( + x.shape, fSize, stride, pad); + }); + + return this.pool(minPoolProgram, x, fSize, stride, pad); + } + + protected avgPoolInternal( + x: Array3D, fSize: number, stride: number, pad: number): Array3D { + const avgPoolProgKey = + [AVG_POOL_PROG, x.shape, fSize, stride, pad].join('_'); + const avgPoolProgram = this.getAndSaveProgram(avgPoolProgKey, () => { + return avg_pool_gpu.getFragmentShaderAvgPoolSource( + x.shape, fSize, stride, pad); + }); + + return this.pool(avgPoolProgram, x, fSize, stride, pad); + } + + protected maxPoolBackpropInternal( + dy: Array3D, x: Array3D, fSize: number, origStride: number, + origPad: number): Array3D { + const maxPoolPositionsProgKey = [ + MAX_POOL_POSITIONS_PROG, x.shape, fSize, origStride, origPad + ].join('_'); + const maxPoolPositionsProgram = + this.getAndSaveProgram(maxPoolPositionsProgKey, () => { + return max_pool_gpu.getFragmentShaderMaxPoolPositionsSource( + x.shape, fSize, origStride, origPad); + }); + + const maxPoolResultShape = conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], origStride, origPad); + const maxPoolResultTexShape = + conv_util.computeTexShapeFrom3D(maxPoolResultShape); + const maxPoolPositionsResultTex = + this.textureManager.acquireTexture(maxPoolResultTexShape); + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const xTexShape = conv_util.computeTexShapeFrom3D(x.shape); + const actualXTexShape = x.getTextureShapeRC(xTexShape); + let cleanupX = false; + if (!util.arraysEqual(actualXTexShape, xTexShape)) { + x = this.reshapeTexture(x, xTexShape); + cleanupX = true; + } + + max_pool_gpu.maxPoolCommon( + this.gpgpu, maxPoolPositionsProgram, x.getTexture(), + maxPoolPositionsResultTex, maxPoolResultTexShape); + + const maxPoolBackpropProgKey = [ + MAX_POOL_BACKPROP_PROG, dy.shape, fSize, origStride, origPad + ].join('_'); + const program = this.getAndSaveProgram(maxPoolBackpropProgKey, () => { + return max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop( + dy.shape, fSize, origStride, origPad); + }); + + const dyTexShape = conv_util.computeTexShapeFrom3D(dy.shape); + + // If the texture shapes doesn't match the shapes that shaders expect, + // do physical texture reshapes on the GPU. + const actualDyTexShape = dy.getTextureShapeRC(dyTexShape); + let cleanupDy = false; + if (!util.arraysEqual(actualDyTexShape, dyTexShape)) { + dy = this.reshapeTexture(dy, dyTexShape); + cleanupDy = true; + } + + const dilatedDyRC = + conv_util.computeDilatedRC([dy.shape[0], dy.shape[1]], origStride); + const pad = fSize - 1 - origPad; + const resultShapeRCD = conv_util.computeOutputShape3D( + [dilatedDyRC[0], dilatedDyRC[1], dy.shape[2]], fSize, dy.shape[2], 1, + pad); + const resultTexShape = conv_util.computeTexShapeFrom3D(resultShapeRCD); + const resultTex = this.textureManager.acquireTexture(resultTexShape); + + max_pool_backprop_gpu.maxPoolBackprop( + this.gpgpu, program, dy.getTexture(), maxPoolPositionsResultTex, + resultTex, resultTexShape); + + if (cleanupDy) { + dy.dispose(); + } + + if (cleanupX) { + x.dispose(); + } + + this.textureManager.releaseTexture( + maxPoolPositionsResultTex, maxPoolResultTexShape); + + return NDArray.make( + resultShapeRCD, {texture: resultTex, textureShapeRC: resultTexShape}); + } + + protected resizeBilinear3DInternal( + x: Array3D, newShape2D: [number, number], + alignCorners: boolean): Array3D { + const programKey = + [RESIZE_BILINEAR_PROG, x.shape, newShape2D, alignCorners].join('_'); + + const newShapeRCD: [number, number, number] = + [newShape2D[0], newShape2D[1], x.shape[2]]; + const resultTexShape = conv_util.computeTexShapeFrom3D(newShapeRCD); + + const program = this.getAndSaveProgram( + programKey, + () => resize_bilinear_gpu.getFragmentShaderSource( + x.shape, newShape2D, alignCorners)); + + const resultTexture = this.textureManager.acquireTexture(resultTexShape); + + resize_bilinear_gpu.resizeBilinear( + this.gpgpu, program, x.getTexture(), resultTexture, resultTexShape); + + return NDArray.make( + newShapeRCD, {texture: resultTexture, textureShapeRC: resultTexShape}); + } + + private getAndSaveProgram(programKey: string, getShaderSource: () => string): + WebGLProgram { + if (!(programKey in this.programCache)) { + this.programCache[programKey] = + this.gpgpu.createProgram(getShaderSource()); + } + return this.programCache[programKey]; + } + + private addSubMulDiv( + a: NDArray, b: NDArray, resultShape: number[], + operandA: addsubmuldiv_gpu.OperandType, + opType: addsubmuldiv_gpu.Operation, + operandB: addsubmuldiv_gpu.OperandType): NDArray { + let cleanupB = false; + + const aOrientation = MatrixOrientation.REGULAR; + let bOrientation = MatrixOrientation.REGULAR; + + let logicalBTexShape: [number, number]; + + if (operandA === OperandType.MATRIX && operandB === OperandType.MATRIX) { + util.assertShapesMatch(a.shape, b.shape); + + if (a.inGPU()) { + // Prefer B to have the shape of A. + b.getTextureShapeRC(a.getTextureShapeRC()); + } else if (b.inGPU()) { + // Prefer A to have the shape of B. + a.getTextureShapeRC(b.getTextureShapeRC()); + } + + const aTexShape = a.getTextureShapeRC(); + const bTexShape = b.getTextureShapeRC(); + logicalBTexShape = bTexShape; + + if (a.rank === 1) { + // When dealing with vectors, we can sample in transposed way without + // the need to do physical reshape. + if (!util.arraysEqual(bTexShape, aTexShape)) { + bOrientation = MatrixOrientation.TRANSPOSED; + logicalBTexShape = [bTexShape[1], bTexShape[0]]; + } + } + + if (!util.arraysEqual(aTexShape, logicalBTexShape)) { + b = this.reshapeTexture(b, aTexShape); + bOrientation = MatrixOrientation.REGULAR; + logicalBTexShape = b.getTextureShapeRC(); + cleanupB = true; + } + } else { + logicalBTexShape = b.getTextureShapeRC(); + } + + const aTexShape = a.getTextureShapeRC(); + const bTexShape = b.getTextureShapeRC(); + + const programKey = [ + ADD_SUM_MUL_DIV_PROG, operandA, aOrientation, opType, operandB, + bOrientation + ].join('_'); + const program = this.getAndSaveProgram( + programKey, + () => addsubmuldiv_gpu.getFragmentShaderSource( + operandA, aOrientation, opType, operandB, bOrientation)); + + const resultTextureShape: [number, number] = [ + Math.max(aTexShape[0], logicalBTexShape[0]), + Math.max(aTexShape[1], logicalBTexShape[1]) + ]; + + const resultTexture = + this.textureManager.acquireTexture(resultTextureShape); + + addsubmuldiv_gpu.addSubMulDiv( + this.gpgpu, program, a.getTexture(), aTexShape, b.getTexture(), + bTexShape, resultTexture, resultTextureShape); + + if (cleanupB) { + b.dispose(); + } + + return NDArray.make( + resultShape, + {texture: resultTexture, textureShapeRC: resultTextureShape}); + } + + private doGPUShapesMatch(a: NDArray, b: NDArray): boolean { + util.assertShapesMatch(a.shape, b.shape); + if (a.inGPU()) { + // Prefer B to have the shape of A. + b.getTextureShapeRC(a.getTextureShapeRC()); + } else if (b.inGPU()) { + // Prefer A to have the shape of B. + a.getTextureShapeRC(b.getTextureShapeRC()); + } + return util.arraysEqual(a.getTextureShapeRC(), b.getTextureShapeRC()); + } + + getTextureManager(): TextureManager { + return this.textureManager; + } + + dispose() { + for (const programKey in this.programCache) { + if (this.programCache.hasOwnProperty(programKey)) { + this.gpgpu.deleteProgram(this.programCache[programKey]); + } + } + this.textureManager.dispose(); + + if (this.gpgpuCreatedLocally) { + this.gpgpu.dispose(); + } + } +} diff --git a/src/math/math_gpu_test.ts b/src/math/math_gpu_test.ts new file mode 100644 index 0000000000..da830c2d3a --- /dev/null +++ b/src/math/math_gpu_test.ts @@ -0,0 +1,2134 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../test_util'; +import * as util from '../util'; + +import {NDArrayMathGPU} from './math_gpu'; +import {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from './ndarray'; +import * as webgl_util from './webgl/webgl_util'; + + +describe('NDArrayMathGPU scope', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + }); + + it('basic scope usage with a return', () => { + const a = Array1D.new([1, 2, 3]); + let b = Array1D.new([0, 0, 0]); + + const numUsedTexturesBefore = math.getTextureManager().getNumUsedTextures(); + + math.scope(() => { + const result = math.scope(() => { + b = math.add(a, b); + b = math.add(a, b); + b = math.add(a, b); + return math.add(a, b); + }); + + // a, b, and result are new textures. All intermediates should be + // disposed. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 3); + expect(result.getValues()).toEqual(new Float32Array([4, 8, 12])); + }); + + // a, b are new textures, result should be disposed. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 2); + a.dispose(); + b.dispose(); + }); + + it('basic scope usage without return', () => { + const a = Array1D.new([1, 2, 3]); + let b = Array1D.new([0, 0, 0]); + + const numUsedTexturesBefore = math.getTextureManager().getNumUsedTextures(); + + math.scope(() => { + b = math.add(a, b); + b = math.add(a, b); + b = math.add(a, b); + math.add(a, b); + }); + + const numUsedTexturesAfter = math.getTextureManager().getNumUsedTextures(); + + // original a and b, all intermediates should be disposed. + expect(numUsedTexturesAfter).toEqual(numUsedTexturesBefore + 2); + }); + + it('nested scope usage', () => { + const a = Array1D.new([1, 2, 3]); + let b = Array1D.new([0, 0, 0]); + + const numUsedTexturesBefore = math.getTextureManager().getNumUsedTextures(); + + math.scope(() => { + const result = math.scope(() => { + b = math.add(a, b); + b = math.scope(() => { + b = math.scope(() => { + return math.add(a, b); + }); + // a, original b, and two intermediate textures should be the only + // textures. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 4); + + math.scope(() => { + math.add(a, b); + }); + // All the intermediates should be cleaned up. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 4); + + return math.add(a, b); + }); + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 4); + + return math.add(a, b); + }); + + // a, b, and result are new textures. All intermediates should be + // disposed. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 3); + expect(result.getValues()).toEqual(new Float32Array([4, 8, 12])); + }); + // a, b, are new textures, result should be disposed. + expect(math.getTextureManager().getNumUsedTextures()) + .toEqual(numUsedTexturesBefore + 2); + }); +}); + +describe('NDArrayMathGPU clone', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('returns a ndarray with the same shape and value', () => { + const a = Array2D.new([3, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9]); + const aPrime = math.clone(a); + expect(aPrime.shape).toEqual(a.shape); + expect(aPrime.getValues()).toEqual(a.getValues()); + a.dispose(); + }); + + it('returns a ndarray with a different texture handle', () => { + const a = Array2D.new([3, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9]); + const aPrime = math.clone(a); + expect(a.inGPU()).toEqual(true); + expect(aPrime.inGPU()).toEqual(true); + expect(aPrime.getTexture()).not.toBe(a.getTexture()); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU slice2D', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('slicing a 1x1 from a 1x1 returns a 1x1', () => { + const a = Array2D.new([1, 1], [0]); + const b = math.slice2D(a, [0, 0], [1, 1]); + expect(b.shape).toEqual([1, 1]); + a.dispose(); + }); + + it('returns a ndarray of slice size', () => { + const a = Array2D.zeros([100, 100]); + const b = math.slice2D(a, [0, 0], [12, 34]); + expect(b.shape).toEqual([12, 34]); + a.dispose(); + }); + + it('returns the upper-left submatrix when begin is [0, 0]', () => { + const a = NDArray.randUniform([10, 10], -1, 1); + const b = math.slice2D(a, [0, 0], [2, 2]); + const aValues = a.getValues(); + const expected = + new Float32Array([aValues[0], aValues[1], aValues[10], aValues[11]]); + test_util.expectArraysClose(b.getValues(), expected, 0); + a.dispose(); + }); + + it('returns the rectangle specified', () => { + const a = Array2D.new([4, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const b = math.slice2D(a, [1, 1], [3, 2]); + const expected = new Float32Array([5, 6, 8, 9, 11, 12]); + expect(b.getValues()).toEqual(expected); + a.dispose(); + }); + + it('throws when requesting out of bounds slice', () => { + const a = Array2D.new([4, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + expect(() => math.slice2D(a, [1, 1], [10, 10])).toThrowError(); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU copy2D', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('throws an error if source and dest shapes have different areas', () => { + const source = Array2D.zeros([100, 100]); + const dest = Array2D.zeros([100, 100]); + const sourceSize: [number, number] = [20, 20]; + const destSize: [number, number] = [5, 5]; + expect( + () => math.copy2D(source, [0, 0], sourceSize, dest, [0, 0], destSize)) + .toThrowError(); + source.dispose(); + dest.dispose(); + }); + + it('copies a src shape into a dst shape', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + math.copy2D(source, [1, 1], [2, 3], dest, [2, 0], [3, 2]); + expect(dest.getValues()).toEqual(new Float32Array([ + 0, 0, 0, 0, 6, 7, 8, 10, 11, 12, 0, 0 + ])); + source.dispose(); + dest.dispose(); + }); + + it('throws when requesting out of bounds source copy', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + + expect(() => math.copy2D(source, [1, 1], [10, 10], dest, [2, 0], [ + 3, 2 + ])).toThrowError(); + source.dispose(); + dest.dispose(); + }); + + it('throws when requesting out of bounds dest copy', () => { + const source = Array2D.new([3, 4], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const dest = Array2D.zeros([6, 2]); + + expect(() => math.copy2D(source, [1, 1], [2, 3], dest, [2, 0], [ + 3, 10 + ])).toThrowError(); + source.dispose(); + dest.dispose(); + }); +}); + +describe('NDArrayMathGPU scaledNDArrayAdd', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('with 2D ndarrays', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + const expected = new Float32Array([8, 16, 24, 32, 40, 48]); + const result = math.scaledArrayAdd(c1, a, c2, b); + + expect(result.shape).toEqual([2, 3]); + expect(result.getValues()).toEqual(expected); + + a.dispose(); + b.dispose(); + c1.dispose(); + c2.dispose(); + }); + + it('with 3D ndarrays', () => { + const a = Array3D.new([2, 2, 2], [2, 4, 6, 8, 10, 12, 3, 5]); + const b = Array3D.new([2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + const expected = new Float32Array([8, 16, 24, 32, 40, 48, 23, 31]); + const result = math.scaledArrayAdd(c1, a, c2, b); + + expect(result.shape).toEqual([2, 2, 2]); + expect(result.getValues()).toEqual(expected); + + a.dispose(); + b.dispose(); + c1.dispose(); + c2.dispose(); + }); + + it('throws when passed non-scalars', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c1 = Array1D.randNormal([10]); + const c2 = Scalar.new(2); + + expect(() => math.scaledArrayAdd(c1 as Scalar, a, c2, b)) + .toThrowError(); + expect(() => math.scaledArrayAdd(c2, a, c1 as Scalar, b)) + .toThrowError(); + + a.dispose(); + b.dispose(); + c1.dispose(); + c2.dispose(); + }); + + it('throws when NDArrays are different shape', () => { + const a = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + const b = Array2D.new([2, 4], [1, 2, 3, 4, 5, 6, 7, 8]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + expect(() => math.scaledArrayAdd(c1, a, c2, b)).toThrowError(); + + a.dispose(); + b.dispose(); + c1.dispose(); + c2.dispose(); + }); +}); + +describe('NDArrayMathGPU concat3D', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('concat axis=0', () => { + const axis = 0; + const x1 = Array3D.new([1, 2, 3], [1, 11, 111, 2, 22, 222]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const y = math.concat3D(x1, x2, axis); + + expect(y.shape).toEqual([3, 2, 3]); + expect(y.getValues()).toEqual(new Float32Array([ + 1, 11, 111, 2, 22, 222, 5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888 + ])); + }); + + it('concat axis=1', () => { + const axis = 1; + const x1 = Array3D.new([2, 1, 3], [1, 11, 111, 3, 33, 333]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const result = math.concat3D(x1, x2, axis); + + expect(result.shape).toEqual([2, 3, 3]); + expect(result.getValues()).toEqual(new Float32Array([ + 1, 11, 111, 5, 55, 555, 6, 66, 666, 3, 33, 333, 7, 77, 777, 8, 88, 888 + ])); + }); + + it('concat axis=2', () => { + const axis = 2; + const x1 = Array3D.new([2, 2, 2], [1, 11, 2, 22, 3, 33, 4, 44]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + const result = math.concat3D(x1, x2, axis); + + expect(result.shape).toEqual([2, 2, 5]); + expect(result.getValues()).toEqual(new Float32Array([ + 1, 11, 5, 55, 555, 2, 22, 6, 66, 666, + 3, 33, 7, 77, 777, 4, 44, 8, 88, 888 + ])); + }); + + it('concat throws when invalid non-axis shapes, axis=0', () => { + const axis = 0; + const x1 = Array3D.new([1, 1, 3], [1, 11, 111]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); + + it('concat throws when invalid non-axis shapes, axis=1', () => { + const axis = 1; + const x1 = Array3D.new([1, 1, 3], [1, 11, 111]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); + + it('concat throws when invalid non-axis shapes, axis=2', () => { + const axis = 2; + const x1 = Array3D.new([1, 2, 2], [1, 11, 2, 22]); + const x2 = Array3D.new( + [2, 2, 3], [5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + expect(() => math.concat3D(x1, x2, axis)).toThrowError(); + }); +}); + +describe('NDArrayMathGPU matMul', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('multiplies matrices', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([3, 2], [0, 1, -3, 2, 2, 1]); + const c = math.matMul(a, b); + expect(c.shape).toEqual([2, 2]); + expect(c.getValues()).toEqual(new Float32Array([0, 8, -3, 20])); + + a.dispose(); + b.dispose(); + c.dispose(); + }); + + it('with implicit texture reshaping on GPU', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + // Make the texture shape different than the logical shape on purpose. + expect(a.getTextureShapeRC([6, 1])).toEqual([6, 1]); + + const b = Array2D.new([3, 2], [1, 3, 0, 1, 2, 0]); + expect(b.getTextureShapeRC()).toEqual([3, 2]); + + // Matmul should do implicit texture reshape on ndarray A in order to + // do the right logical multiplication. + const result = math.matMul(a, b); + expect(result.shape).toEqual([2, 2]); + expect(result.getTextureShapeRC()).toEqual([2, 2]); + expect(result.getValues()).toEqual(new Float32Array([7, 5, 16, 17])); + a.dispose(); + b.dispose(); + }); + + it('matmul throws when inner dimensions dont match', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = Array2D.new([4, 2], [0, 1, -3, 2, 2, 1, 2, 2]); + expect(() => math.matMul(a, b)).toThrowError(); + + a.dispose(); + b.dispose(); + }); + + it('matmul throws when passed non matrices', () => { + // tslint:disable-next-line:no-any + const a: any = + Array3D.new([2, 3, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const b = Array2D.new([4, 2], [0, 1, -3, 2, 2, 1, 2, 2]); + expect(() => math.matMul(a, b)).toThrowError(); + expect(() => math.matMul(b, a)).toThrowError(); + + a.dispose(); + b.dispose(); + }); + + it('Vector times matrix', () => { + const v = Array1D.new([2, 3]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const result = math.vectorTimesMatrix(v, matrix); + + const expected = new Float32Array([11, 16]); + expect(result.getValues()).toEqual(expected); + v.dispose(); + matrix.dispose(); + result.dispose(); + }); + + it('Vector times matrix with implicit reshape', () => { + const v = Array1D.new([2, 3]); + // Make the texture shape be column on purpose. + expect(v.getTextureShapeRC([2, 1])).toEqual([2, 1]); + + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const result = math.vectorTimesMatrix(v, matrix); + + const expected = new Float32Array([11, 16]); + expect(result.getValues()).toEqual(expected); + v.dispose(); + matrix.dispose(); + }); + + it('Vector times matrix throws when not passed a vector', () => { + // tslint:disable-next-line:no-any + const v: any = Array2D.new([2, 2], [1, 2, 3, 4]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + expect(() => math.vectorTimesMatrix(v, matrix)).toThrowError(); + }); + + it('Vector times matrix throws when not passed a matrix', () => { + const v = Array1D.new([2, 3]); + // tslint:disable-next-line:no-any + const matrix: any = Array3D.new([2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]); + expect(() => math.vectorTimesMatrix(v, matrix)).toThrowError(); + }); + + it('Matrix times vector', () => { + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const v = Array1D.new([2, 3]); + const result = math.matrixTimesVector(matrix, v); + + const expected = new Float32Array([8, 18]); + expect(result.getValues()).toEqual(expected); + matrix.dispose(); + v.dispose(); + }); + + it('Matrix times vector, larger than max texture size', () => { + const maxTexSize = + webgl_util.queryMaxTextureSize(math.getGPGPUContext().gl); + const matrix = Array2D.zeros([1, maxTexSize + 4]); + matrix.fill(1); + const v = Array1D.zeros([maxTexSize + 4]); + v.fill(1); + const result = math.matrixTimesVector(matrix, v); + const expected = new Float32Array([maxTexSize + 4]); + expect(result.getValues()).toEqual(expected); + + matrix.dispose(); + v.dispose(); + }); + + it('Matrix * vector propagates NaNs', () => { + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const v = Array1D.new([2, NaN]); + const result = math.matrixTimesVector(matrix, v); + + const expected = new Float32Array([NaN, NaN]); + expect(result.getValues()).toEqual(expected); + + matrix.dispose(); + v.dispose(); + }); + + it('Matrix times vector with implicit reshape', () => { + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + const v = Array1D.new([2, 3]); + // Make the texture shape be row on purpose. + expect(v.getTextureShapeRC([1, 2])).toEqual([1, 2]); + const result = math.matrixTimesVector(matrix, v); + + const expected = new Float32Array([8, 18]); + expect(result.getValues()).toEqual(expected); + matrix.dispose(); + v.dispose(); + }); + + it('matrix times vector throws when not passed a vector', () => { + // tslint:disable-next-line:no-any + const v: any = Array2D.new([2, 2], [1, 2, 3, 4]); + const matrix = Array2D.new([2, 2], [1, 2, 3, 4]); + expect(() => math.matrixTimesVector(matrix, v)).toThrowError(); + }); + + it('matrix times vector throws when not passed a matrix', () => { + const v = Array1D.new([2, 3]); + // tslint:disable-next-line:no-any + const matrix: any = Array3D.new([2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]); + expect(() => math.matrixTimesVector(matrix, v)).toThrowError(); + }); + + it('Dot product', () => { + const v1 = Array1D.new([2, 3]); + const v2 = Array1D.new([2, 1]); + const result = math.dotProduct(v1, v2); + + expect(result.get()).toEqual(7); + v1.dispose(); + v2.dispose(); + result.dispose(); + }); + + it('Dot product propagates NaNs', () => { + const v1 = Array1D.new([2, NaN]); + const v2 = Array1D.new([2, 1]); + const result = math.dotProduct(v1, v2); + expect(result.get()).toEqual(NaN); + + v1.dispose(); + v2.dispose(); + }); + + it('Dot product with implicit reshaping', () => { + const v1 = Array1D.new([2, 3]); + // Make the texture shape be column on purpose. + expect(v1.getTextureShapeRC([2, 1])).toEqual([2, 1]); + + const v2 = Array1D.new([2, 1]); + // Make the texture shape be row on purpose. + expect(v2.getTextureShapeRC([1, 2])).toEqual([1, 2]); + + const result = math.dotProduct(v1, v2); + expect(result.get()).toEqual(7); + v1.dispose(); + v2.dispose(); + }); + + it('Dot product throws when vectors are different size', () => { + const v1 = Array1D.new([2, 3, 3]); + const v2 = Array1D.new([2, 1]); + expect(() => math.dotProduct(v1, v2)).toThrowError(); + expect(() => math.dotProduct(v2, v1)).toThrowError(); + + v1.dispose(); + v2.dispose(); + }); + + it('Dot product throws when passed non vectors', () => { + // tslint:disable-next-line:no-any + const v1: any = Array2D.new([2, 2], [1, 2, 3, 3]); + const v2 = Array1D.new([2, 1]); + expect(() => math.dotProduct(v1, v2)).toThrowError(); + expect(() => math.dotProduct(v2, v1)).toThrowError(); + + v1.dispose(); + v2.dispose(); + }); + + it('Outer product', () => { + const v1 = Array1D.new([2, 3]); + const v2 = Array1D.new([2, 1]); + const result = math.outerProduct(v1, v2); + + const expected = new Float32Array([4, 2, 6, 3]); + expect(result.shape).toEqual([2, 2]); + expect(result.getValues()).toEqual(expected); + v1.dispose(); + v2.dispose(); + }); + + it('Outer product with implicit reshape', () => { + const v1 = Array1D.new([2, 3]); + // Make the texture shape be row on purpose. + expect(v1.getTextureShapeRC([1, 2])).toEqual([1, 2]); + + const v2 = Array1D.new([2, 1]); + // Make the texture shape be column on purpose. + expect(v2.getTextureShapeRC([2, 1])).toEqual([2, 1]); + + const result = math.outerProduct(v1, v2); + const expected = new Float32Array([4, 2, 6, 3]); + expect(result.shape).toEqual([2, 2]); + expect(result.getValues()).toEqual(expected); + v1.dispose(); + v2.dispose(); + }); +}); + +describe('NDArrayMathGPU element-wise mul/div', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('multiplies same-shaped ndarrays', () => { + const a = Array2D.new([2, 2], [1, 2, -3, -4]); + const b = Array2D.new([2, 2], [5, 3, 4, -7]); + const expected = new Float32Array([5, 6, -12, 28]); + const result = math.elementWiseMul(a, b); + + expect(result.shape).toEqual([2, 2]); + expect(result.inGPU()).toBe(true); + expect(result.getValues()).toEqual(expected); + expect(result.inGPU()).toBe(false); + + a.dispose(); + b.dispose(); + }); + + it('propagates NaNs', () => { + const a = Array2D.new([2, 2], [1, 3, 4, 0]); + const b = Array2D.new([2, 2], [NaN, 3, NaN, 3]); + const result = math.elementWiseMul(a, b).getValues(); + expect(result).toEqual(new Float32Array([NaN, 9, NaN, 0])); + + a.dispose(); + b.dispose(); + }); + + it('mul throws when passed ndarrays of different shapes', () => { + const a = Array2D.new([2, 3], [1, 2, -3, -4, 5, 6]); + const b = Array2D.new([2, 2], [5, 3, 4, -7]); + expect(() => math.elementWiseMul(a, b)).toThrowError(); + expect(() => math.elementWiseMul(b, a)).toThrowError(); + + a.dispose(); + b.dispose(); + }); + + it('divide', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c = Array2D.new([2, 3], [1, 2, 3, 4, 2, 5]); + const r = math.divide(a, c); + + expect(r.get(0, 0)).toBeCloseTo(1); + expect(r.get(0, 1)).toBeCloseTo(1); + expect(r.get(0, 2)).toBeCloseTo(1); + expect(r.get(1, 0)).toBeCloseTo(1); + expect(r.get(1, 1)).toBeCloseTo(2.5); + expect(r.get(1, 2)).toBeCloseTo(6 / 5); + + a.dispose(); + c.dispose(); + }); + + it('divide propagates NaNs', () => { + const a = Array2D.new([2, 1], [1, 2]); + const c = Array2D.new([2, 1], [3, NaN]); + const r = math.divide(a, c).getValues(); + expect(r[0]).toBeCloseTo(1 / 3); + expect(r[1]).toEqual(NaN); + + a.dispose(); + c.dispose(); + }); + + it('div throws when passed ndarrays of different shapes', () => { + const a = Array2D.new([2, 3], [1, 2, -3, -4, 5, 6]); + const b = Array2D.new([2, 2], [5, 3, 4, -7]); + expect(() => math.divide(a, b)).toThrowError(); + expect(() => math.divide(b, a)).toThrowError(); + + a.dispose(); + b.dispose(); + }); + + it('scalar divided by array', () => { + const c = Scalar.new(2); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + const r = math.scalarDividedByArray(c, a); + + expect(r.get(0, 0)).toBeCloseTo(2 / 1); + expect(r.get(0, 1)).toBeCloseTo(2 / 2); + expect(r.get(0, 2)).toBeCloseTo(2 / 3); + expect(r.get(1, 0)).toBeCloseTo(2 / 4); + expect(r.get(1, 1)).toBeCloseTo(2 / 5); + expect(r.get(1, 2)).toBeCloseTo(2 / 6); + + a.dispose(); + c.dispose(); + }); + + it('scalar divided by array propagates NaNs', () => { + const c = Scalar.new(NaN); + const a = Array2D.new([1, 3], [1, 2, 3]); + const r = math.scalarDividedByArray(c, a).getValues(); + expect(r).toEqual(new Float32Array([NaN, NaN, NaN])); + + a.dispose(); + c.dispose(); + }); + + it('scalar divided by array throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + expect(() => math.scalarDividedByArray(c, a)).toThrowError(); + + a.dispose(); + c.dispose(); + }); + + it('array divided by scalar', () => { + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const c = Scalar.new(2); + + const r = math.arrayDividedByScalar(a, c); + + expect(r.get(0, 0)).toBeCloseTo(1 / 2); + expect(r.get(0, 1)).toBeCloseTo(2 / 2); + expect(r.get(0, 2)).toBeCloseTo(3 / 2); + expect(r.get(1, 0)).toBeCloseTo(4 / 2); + expect(r.get(1, 1)).toBeCloseTo(5 / 2); + expect(r.get(1, 2)).toBeCloseTo(6 / 2); + + a.dispose(); + c.dispose(); + }); + + it('array divided by scalar propagates NaNs', () => { + const a = Array2D.new([1, 3], [1, 2, NaN]); + const c = Scalar.new(2); + const r = math.arrayDividedByScalar(a, c).getValues(); + expect(r[0]).toBeCloseTo(1 / 2); + expect(r[1]).toBeCloseTo(2 / 2); + expect(r[2]).toEqual(NaN); + + a.dispose(); + c.dispose(); + }); + + it('array divided by scalar throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + expect(() => math.arrayDividedByScalar(a, c)).toThrowError(); + + a.dispose(); + c.dispose(); + }); +}); + +describe('NDArrayMathGPU unary ops', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('relu', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1]); + const result = math.relu(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 3, 0])); + + a.dispose(); + }); + + it('relu propagates NaNs', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1, NaN]); + const result = math.relu(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 3, 0, NaN])); + a.dispose(); + }); + + it('step with 1d ndarray', () => { + const a = Array1D.new([1, -2, 0, 3, -0.1]); + const result = math.step(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 1, 0])); + + a.dispose(); + }); + + it('step with 2d ndarray', () => { + const a = Array2D.new([2, 2], [1, -5, -3, 4]); + const result = math.step(a); + + expect(result.shape).toEqual([2, 2]); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 1])); + + a.dispose(); + }); + + it('step propagates NaNs', () => { + const a = Array1D.new([1, -2, 0, 3, NaN]); + const result = math.step(a); + expect(result.getValues()).toEqual(new Float32Array([1, 0, 0, 1, NaN])); + a.dispose(); + }); + + it('neg', () => { + const a = Array1D.new([1, -3, 2, 7, -4]); + const result = math.neg(a); + expect(result.getValues()).toEqual(new Float32Array([-1, 3, -2, -7, 4])); + + a.dispose(); + }); + + it('neg propagate NaNs', () => { + const a = Array1D.new([1, -3, 2, 7, NaN]); + const expected = [-1, 3, -2, -7, NaN]; + expect(math.neg(a).getValues()).toEqual(new Float32Array(expected)); + a.dispose(); + }); + + it('tanh', () => { + const values = [1, -3, 2, 7, -4]; + const a = Array1D.new(values); + const result = math.tanh(a); + const expected = new Float32Array(a.size); + for (let i = 0; i < a.size; i++) { + expected[i] = util.tanh(values[i]); + } + test_util.expectArraysClose(result.getValues(), expected, 1e-6); + + a.dispose(); + }); + + it('tanh propagates NaNs', () => { + const a = Array1D.new([4, NaN, 0]); + const res = math.tanh(a).getValues(); + const expected = [util.tanh(4), NaN, util.tanh(0)]; + test_util.expectArraysClose(res, new Float32Array(expected), 1e-5); + a.dispose(); + }); + + it('sigmoid', () => { + const values = [1, -3, 2, 7, -4]; + const a = Array1D.new(values); + const result = math.sigmoid(a); + const expected = new Float32Array(a.size); + for (let i = 0; i < a.size; i++) { + expected[i] = 1 / (1 + Math.exp(-values[i])); + } + test_util.expectArraysClose(result.getValues(), expected, 1e-6); + + a.dispose(); + }); + + it('sigmoid propagates NaNs', () => { + const a = Array1D.new([3, NaN]); + const res = math.sigmoid(a).getValues(); + test_util.expectArraysClose( + res, new Float32Array([1 / (1 + Math.exp(-3)), NaN]), 1e-5); + a.dispose(); + }); + + it('sin', () => { + const values = [1, -3, 2, 7, -4]; + const a = Array1D.new(values); + const result = math.sin(a); + const expected = new Float32Array(a.size); + for (let i = 0; i < a.size; i++) { + expected[i] = Math.sin(values[i]); + } + test_util.expectArraysClose(result.getValues(), expected, 1e-3); + + a.dispose(); + }); + + it('sin propagates NaNs', () => { + const a = Array1D.new([4, NaN, 0]); + const res = math.sin(a).getValues(); + const expected = [Math.sin(4), NaN, Math.sin(0)]; + test_util.expectArraysClose(res, new Float32Array(expected), 1e-4); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU min/max', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('max with one element dominating', () => { + const a = Array1D.new([3, -1, 0, 100, -7, 2]); + const r = math.max(a); + + expect(r.get()).toBe(100); + + a.dispose(); + }); + + it('max with all elements being the same', () => { + const a = Array1D.new([3, 3, 3]); + const r = math.max(a); + expect(r.get()).toBe(3); + + a.dispose(); + }); + + it('max propagates NaNs', () => { + expect(math.max(Array1D.new([3, NaN, 2])).get()).toEqual(NaN); + }); + + it('min Array1D', () => { + const a = Array1D.new([3, -1, 0, 100, -7, 2]); + expect(math.min(a).get()).toBe(-7); + a.dispose(); + }); + + it('min propagates NaNs', () => { + const a = Array1D.new([3, NaN, 2]); + expect(math.min(a).get()).toEqual(NaN); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU scalar and element-wise', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('c + A', () => { + const c = Scalar.new(5); + const a = Array1D.new([1, 2, 3]); + const result = math.scalarPlusArray(c, a); + expect(result.getValues()).toEqual(new Float32Array([6, 7, 8])); + + a.dispose(); + c.dispose(); + }); + + it('c + A propagates NaNs', () => { + const c = Scalar.new(NaN); + const a = Array1D.new([1, 2, 3]); + const res = math.scalarPlusArray(c, a).getValues(); + expect(res).toEqual(new Float32Array([NaN, NaN, NaN])); + a.dispose(); + c.dispose(); + }); + + it('c + A throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.scalarPlusArray(c, a)).toThrowError(); + + a.dispose(); + c.dispose(); + }); + + it('c - A', () => { + const c = Scalar.new(5); + const a = Array1D.new([7, 2, 3]); + const result = math.scalarMinusArray(c, a); + expect(result.getValues()).toEqual(new Float32Array([-2, 3, 2])); + + a.dispose(); + c.dispose(); + }); + + it('c - A throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.scalarMinusArray(c, a)).toThrowError(); + + a.dispose(); + c.dispose(); + }); + + it('A - c', () => { + const a = Array1D.new([1, 2, -3]); + const c = Scalar.new(5); + const result = math.arrayMinusScalar(a, c); + expect(result.getValues()).toEqual(new Float32Array([-4, -3, -8])); + + a.dispose(); + c.dispose(); + result.dispose(); + }); + + it('A - c propagates NaNs', () => { + const a = Array1D.new([1, NaN, 3]); + const c = Scalar.new(5); + const res = math.arrayMinusScalar(a, c).getValues(); + expect(res).toEqual(new Float32Array([-4, NaN, -2])); + a.dispose(); + c.dispose(); + }); + + it('A - c throws when passed non scalar', () => { + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3]); + const a = Array1D.new([1, 2, 3]); + expect(() => math.arrayMinusScalar(a, c)).toThrowError(); + + a.dispose(); + c.dispose(); + }); + + it('A - B', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, 2, -1]); + const expected = new Float32Array([-2, 3, 2]); + const result = math.sub(a, b); + + expect(result.getValues()).toEqual(expected); + + a.dispose(); + b.dispose(); + }); + + it('A - B propagates NaNs', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, NaN, -1]); + const res = math.sub(a, b).getValues(); + expect(res).toEqual(new Float32Array([-2, NaN, 2])); + + a.dispose(); + b.dispose(); + }); + + it('A - B throws when passed ndarrays with different shape', () => { + const a = Array1D.new([2, 5, 1, 5]); + const b = Array1D.new([4, 2, -1]); + expect(() => math.sub(a, b)).toThrowError(); + expect(() => math.sub(b, a)).toThrowError(); + + a.dispose(); + b.dispose(); + }); + + it('A + B', () => { + const a = Array1D.new([2, 5, 1]); + const b = Array1D.new([4, 2, -1]); + const expected = new Float32Array([6, 7, 0]); + const result = math.add(a, b); + + expect(result.getValues()).toEqual(expected); + + a.dispose(); + b.dispose(); + }); + + it('A + B propagates NaNs', () => { + const a = Array1D.new([2, 5, NaN]); + const b = Array1D.new([4, 2, -1]); + const res = math.add(a, b).getValues(); + expect(res).toEqual(new Float32Array([6, 7, NaN])); + + a.dispose(); + b.dispose(); + }); + + it('A + B throws when passed ndarrays with different shape', () => { + const a = Array1D.new([2, 5, 1, 5]); + const b = Array1D.new([4, 2, -1]); + expect(() => math.add(a, b)).toThrowError(); + expect(() => math.add(b, a)).toThrowError(); + + a.dispose(); + b.dispose(); + }); +}); + +describe('NDArrayMathGPU scalarTimesNDArray', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('scalar times ndarray', () => { + const a = Array2D.new([3, 2], [2, -5, 1, 1, 4, 0]); + const c = Scalar.new(2); + const expected = new Float32Array([4, -10, 2, 2, 8, 0]); + const result = math.scalarTimesArray(c, a); + + expect(result.shape).toEqual([3, 2]); + expect(result.getValues()).toEqual(expected); + + a.dispose(); + c.dispose(); + }); + + it('scalar times ndarray throws when passed non-scalar', () => { + const a = Array2D.new([3, 2], [2, -5, 1, 1, 4, 0]); + // tslint:disable-next-line:no-any + const c: any = Array1D.new([1, 2, 3, 4]); + expect(() => math.scalarTimesArray(c, a)).toThrowError(); + + a.dispose(); + c.dispose(); + }); +}); + +describe('NDArrayMathGPU log/exp', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('exp', () => { + const a = Array1D.new([1, 2, 0]); + const r = math.exp(a); + + expect(r.get(0)).toBeCloseTo(Math.exp(1)); + expect(r.get(1)).toBeCloseTo(Math.exp(2)); + expect(r.get(2)).toBeCloseTo(1); + + a.dispose(); + }); + + it('exp propagates NaNs', () => { + const a = Array1D.new([1, NaN, 0]); + const r = math.exp(a).getValues(); + expect(r).toEqual(new Float32Array([Math.exp(1), NaN, 1])); + a.dispose(); + }); + + it('log', () => { + const a = Array1D.new([1, 2]); + const r = math.log(a); + + expect(r.get(0)).toBeCloseTo(Math.log(1)); + expect(r.get(1)).toBeCloseTo(Math.log(2)); + + a.dispose(); + }); + + it('log propagates NaNs', () => { + const a = Array1D.new([1, NaN]); + const r = math.log(a).getValues(); + expect(r).toEqual(new Float32Array([Math.log(1), NaN])); + a.dispose(); + }); + + it('logSumExp', () => { + const a = Array1D.new([1, 2, -3]); + const result = math.logSumExp(a); + expect(result.get()) + .toBeCloseTo(Math.log(Math.exp(1) + Math.exp(2) + Math.exp(-3))); + + a.dispose(); + result.dispose(); + }); + + it('logSumExp propagates NaNs', () => { + const a = Array1D.new([1, 2, NaN]); + const result = math.logSumExp(a); + expect(result.get()).toEqual(NaN); + a.dispose(); + }); +}); + + +describe('softmax', () => { + let math: NDArrayMathGPU; + + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('regular test', () => { + const y = math.softmax(Array1D.new([2, 1, 3])); + expect(y.get(0)).toBeCloseTo(0.24472847, 6); + expect(y.get(1)).toBeCloseTo(0.09003057, 6); + expect(y.get(2)).toBeCloseTo(0.66524095, 6); + expect(y.get(0) + y.get(1) + y.get(2)).toBeCloseTo(1, 6); + }); + + it('overflow', () => { + const y = math.softmax(Array1D.new([10000, 10000])); + expect(y.get(0)).toBeCloseTo(0.5, 3); + expect(y.get(1)).toBeCloseTo(0.5, 3); + }); + + it('underflow', () => { + const y = math.softmax(Array1D.new([-10000, -10000])); + expect(y.get(0)).toBeCloseTo(0.5, 3); + expect(y.get(1)).toBeCloseTo(0.5, 3); + }); + + it('Huge difference between probabilities', () => { + const y = math.softmax(Array1D.new([-10000, +10000])); + expect(y.get(0)).toBeCloseTo(0.0, 6); + expect(y.get(1)).toBeCloseTo(1, 6); + }); + + it('Propagates NaNs', () => { + const a = Array1D.new([2, 1, NaN]); + const y = math.softmax(a); + expect(y.getValues()).toEqual(new Float32Array([NaN, NaN, NaN])); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU sum', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('sum', () => { + const a = Array2D.new([3, 2], [1, 2, 3, 0, 0, 1]); + const result = math.sum(a); + expect(result.get()).toBe(7); + + a.dispose(); + }); + + it('propagates NaNs', () => { + const a = Array2D.new([3, 2], [1, 2, 3, NaN, 0, 1]); + expect(math.sum(a).get()).toEqual(NaN); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU argmax', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('Array1D', () => { + const a = Array1D.new([1, 0, 3, 2]); + const result = math.argMax(a); + expect(result.get()).toBe(2); + + a.dispose(); + }); + + it('propagates NaNs', () => { + const a = Array1D.new([5, 0, 3, NaN, 3]); + expect(math.argMax(a).get()).toEqual(NaN); + a.dispose(); + }); +}); + +describe('NDArrayMathGPU argmin', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('argmin', () => { + const a = Array1D.new([1, 0, 3, 2]); + const result = math.argMin(a); + expect(result.get()).toBe(1); + + a.dispose(); + }); + + it('Arg min propagates NaNs', () => { + const a = Array1D.new([5, 0, NaN, 7, 3]); + expect(math.argMin(a).get()).toEqual(NaN); + + a.dispose(); + }); +}); + +describe('NDArrayMathGPU argmax equals', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('equals', () => { + const a = Array1D.new([5, 0, 3, 7, 3]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5, -100]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toBe(1); + }); + + it('not equals', () => { + const a = Array1D.new([5, 0, 3, 1, 3]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5, 0]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toBe(0); + }); + + it('propagates NaNs', () => { + const a = Array1D.new([0, 3, 1, 3]); + const b = Array1D.new([NaN, -20.0, -10.0, -5]); + const result = math.argMaxEquals(a, b); + expect(result.get()).toEqual(NaN); + }); + + it('throws when given arrays of different shape', () => { + const a = Array1D.new([5, 0, 3, 7, 3, 10]); + const b = Array1D.new([-100.3, -20.0, -10.0, -5, -100]); + expect(() => math.argMaxEquals(a, b)).toThrowError(); + }); +}); + +describe('NDArrayMathGPU conv2d', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('input=2x2x1,d2=1,f=1,s=1,p=0', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 1; + const pad = 0; + const stride = 1; + + const x = Array3D.new(inputShape, [1, 2, 3, 4]); + const w = Array4D.new([fSize, fSize, inputDepth, outputDepth], [2]); + const bias = Array1D.new([-1]); + + const result = math.conv2d(x, w, bias, stride, pad); + const expected = new Float32Array([1, 3, 5, 7]); + + expect(result.inGPU()).toBe(true); + expect(result.getValues()).toEqual(expected); + x.dispose(); + w.dispose(); + bias.dispose(); + }); + + it('input=2x2x1,d2=1,f=2,s=1,p=0', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 2; + const pad = 0; + const stride = 1; + + const x = Array3D.new(inputShape, [1, 2, 3, 4]); + const w = + Array4D.new([fSize, fSize, inputDepth, outputDepth], [3, 1, 5, 0]); + const bias = Array1D.new([-1]); + + const result = math.conv2d(x, w, bias, stride, pad); + const expected = new Float32Array([19]); + + expect(result.inGPU()).toBe(true); + expect(result.getValues()).toEqual(expected); + + x.dispose(); + w.dispose(); + bias.dispose(); + }); + + it('throws when x is not rank 3', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 2; + const pad = 0; + const stride = 1; + + // tslint:disable-next-line:no-any + const x: any = Array2D.new([2, 2], [1, 2, 3, 4]); + const w = + Array4D.new([fSize, fSize, inputDepth, outputDepth], [3, 1, 5, 0]); + const bias = Array1D.new([-1]); + + expect(() => math.conv2d(x, w, bias, stride, pad)).toThrowError(); + + x.dispose(); + w.dispose(); + bias.dispose(); + }); + + it('throws when weights is not rank 4', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 2; + const pad = 0; + const stride = 1; + + const x = Array3D.new(inputShape, [1, 2, 3, 4]); + // tslint:disable-next-line:no-any + const w: any = Array3D.new([2, 2, 1], [3, 1, 5, 0]); + const bias = Array1D.new([-1]); + + expect(() => math.conv2d(x, w, bias, stride, pad)).toThrowError(); + + x.dispose(); + w.dispose(); + bias.dispose(); + }); + + it('throws when biases is not rank 1', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 2; + const pad = 0; + const stride = 1; + + const x = Array3D.new(inputShape, [1, 2, 3, 4]); + const w = + Array4D.new([fSize, fSize, inputDepth, outputDepth], [3, 1, 5, 0]); + // tslint:disable-next-line:no-any + const bias: any = Array2D.new([2, 2], [2, 2, 2, 2]); + + expect(() => math.conv2d(x, w, bias, stride, pad)).toThrowError(); + + x.dispose(); + w.dispose(); + bias.dispose(); + }); + + it('throws when x depth does not match weight depth', () => { + const inputDepth = 1; + const wrongInputDepth = 5; + const inputShape: [number, number, number] = [2, 2, inputDepth]; + const outputDepth = 1; + const fSize = 2; + const pad = 0; + const stride = 1; + + const x = Array3D.new(inputShape, [1, 2, 3, 4]); + const w = NDArray.randNormal( + [fSize, fSize, wrongInputDepth, outputDepth]); + const bias = Array1D.new([-1]); + + expect(() => math.conv2d(x, w, bias, stride, pad)).toThrowError(); + + x.dispose(); + w.dispose(); + bias.dispose(); + }); +}); + +describe('NDArrayMathGPU conv2dTranspose', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('input=2x2x1,d2=1,f=2,s=1,p=0', () => { + const origInputDepth = 1; + const origOutputDepth = 1; + const inputShape: [number, number, number] = [1, 1, origOutputDepth]; + const fSize = 2; + const origPad = 0; + const origStride = 1; + + const x = Array3D.new(inputShape, [2]); + const w = Array4D.new( + [fSize, fSize, origInputDepth, origOutputDepth], [3, 1, 5, 0]); + const b = Array1D.new([1]); + + const result = math.conv2dTranspose(x, w, b, origStride, origPad); + const expected = new Float32Array([7, 3, 11, 1]); + + expect(result.inGPU()).toBe(true); + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(expected); + + x.dispose(); + w.dispose(); + b.dispose(); + }); + + it('throws when x is not rank 3', () => { + const origInputDepth = 1; + const origOutputDepth = 1; + const inputShape: [number, number, number] = [1, 1, origOutputDepth]; + const fSize = 2; + const origPad = 0; + const origStride = 1; + + // tslint:disable-next-line:no-any + const x: any = Array2D.new([2, 1], [2, 2]); + const w = Array4D.new( + [fSize, fSize, origInputDepth, origOutputDepth], [3, 1, 5, 0]); + const b = Array1D.new([1]); + + expect(() => math.conv2dTranspose(x, w, b, origStride, origPad)) + .toThrowError(); + + x.dispose(); + w.dispose(); + b.dispose(); + }); + + it('throws when weights is not rank 4', () => { + const origInputDepth = 1; + const origOutputDepth = 1; + const inputShape: [number, number, number] = [1, 1, origOutputDepth]; + const fSize = 2; + const origPad = 0; + const origStride = 1; + + const x = Array3D.new(inputShape, [2]); + // tslint:disable-next-line:no-any + const w: any = Array3D.new([fSize, fSize, origInputDepth], [3, 1, 5, 0]); + const b = Array1D.new([1]); + + expect(() => math.conv2dTranspose(x, w, b, origStride, origPad)) + .toThrowError(); + + x.dispose(); + w.dispose(); + b.dispose(); + }); + + it('throws when biases is not rank 1', () => { + const origInputDepth = 1; + const origOutputDepth = 1; + const inputShape: [number, number, number] = [1, 1, origOutputDepth]; + const fSize = 2; + const origPad = 0; + const origStride = 1; + + const x = Array3D.new(inputShape, [2]); + const w = Array4D.new( + [fSize, fSize, origInputDepth, origOutputDepth], [3, 1, 5, 0]); + // tslint:disable-next-line:no-any + const b: any = Array2D.new([2, 1], [1, 2]); + + expect(() => math.conv2dTranspose(x, w, b, origStride, origPad)) + .toThrowError(); + + x.dispose(); + w.dispose(); + b.dispose(); + }); + + it('throws when x depth does not match weights original output depth', () => { + const origInputDepth = 1; + const origOutputDepth = 2; + const wrongOrigOutputDepth = 3; + const inputShape: [number, number, number] = [1, 1, origOutputDepth]; + const fSize = 2; + const origPad = 0; + const origStride = 1; + + const x = Array3D.new(inputShape, [2, 2]); + const w = NDArray.randNormal( + [fSize, fSize, origInputDepth, wrongOrigOutputDepth]); + const b = Array1D.new([1]); + + expect(() => math.conv2dTranspose(x, w, b, origStride, origPad)) + .toThrowError(); + + x.dispose(); + w.dispose(); + b.dispose(); + }); +}); + +describe('NDArrayMathGPU conv2dDerWeights', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('conv2dDerWeights input=3x3x1,d2=1,f=2,s=1,p=0', () => { + const inputDepth = 1; + const outputDepth = 1; + const inputShape: [number, number, number] = [3, 3, inputDepth]; + const fSize = 2; + const stride = 1; + const pad = 0; + + const weightsShape = [fSize, fSize, inputDepth, outputDepth]; + + const x = Array3D.new(inputShape, [1, 2, 3, 4, 5, 6, 7, 8, 9]); + const dy = Array3D.new([2, 2, 1], [3, 1, 2, 0]); + + const result = math.conv2dDerWeights(x, dy, fSize, stride, pad); + const expected = new Float32Array([13, 19, 31, 37]); + + expect(result.inGPU()).toBe(true); + expect(result.shape).toEqual(weightsShape); + expect(result.getValues()).toEqual(expected); + + x.dispose(); + dy.dispose(); + }); +}); + +describe('NDArrayMathGPU conv2dDerWeights', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('conv2dDerBias dy=2x2x2', () => { + const outputDepth = 2; + const dyShape: [number, number, number] = [2, 2, outputDepth]; + const dy = Array3D.new(dyShape, [1, 2, 3, 4, 5, 6, 7, 8]); + + const result = math.conv2dDerBias(dy); + const expected = new Float32Array([16, 20]); + + expect(result.inGPU()).toBe(true); + expect(result.shape).toEqual([outputDepth]); + expect(result.getValues()).toEqual(expected); + + dy.dispose(); + }); +}); + +describe('NDArrayMathGPU maxPool', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('3x3x2 in, 2x2 filter, 1 stride', () => { + // Feed forward. + const a = Array3D.new( + [3, 3, 2], + [1, 99, 2, 88, 3, 77, 4, 66, 5, 55, 6, 44, 7, 33, 9, 22, 8, 11]); + const result = math.maxPool(a, 2, 1, 0); + + expect(result.inGPU()).toBe(true); + expect(result.shape).toEqual([2, 2, 2]); + expect(result.getValues()).toEqual(new Float32Array([ + 5, 99, 6, 88, 9, 66, 9, 55 + ])); + a.dispose(); + }); + + it('3x3x1 in, 2x2 filter, 1 stride, propagates NaNs', () => { + const a = Array3D.new([3, 3, 1], [1, 2, 3, 4, 5, 6, 7, NaN, 9]); + const result = math.maxPool(a, 2, 1, 0); + + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([5, 6, NaN, NaN])); + a.dispose(); + }); + + it('4x4x1 in, 2x2 filter, 2 stride', () => { + // Feed forward. + const a = Array3D.new( + [4, 4, 1], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); + const result = math.maxPool(a, 2, 2, 0); + + expect(result.inGPU()).toBe(true); + expect(result.shape).toEqual([2, 2, 1]); + expect(result.getValues()).toEqual(new Float32Array([5, 7, 13, 15])); + + a.dispose(); + }); + + it('throws when x is not rank 3', () => { + // tslint:disable-next-line:no-any + const a: any = Array2D.new([3, 3], [1, 2, 3, 4, 5, 6, 7, 8, 9]); + expect(() => math.maxPool(a, 2, 1, 0)).toThrowError(); + + a.dispose(); + }); +}); + +describe('NDArrayMathGPU maxPoolBackprop', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('x=2x2x1, f=2, s=2, pad=1', () => { + const dy = Array3D.new([2, 2, 1], [1, 2, 3, 4]); + const maxPositions = Array3D.new([2, 2, 1], [3, 2, 1, 0]); + const expected = new Float32Array([1, 2, 3, 4]); + const dx = math.maxPoolBackprop(dy, maxPositions, 2, 2, 1); + + expect(dx.inGPU()).toBe(true); + expect(dx.getValues()).toEqual(expected); + + dy.dispose(); + maxPositions.dispose(); + dx.dispose(); + }); + + // Max pool depth > 1. + it('x=3x3x2, f=2, s=1, no duplicate max value', () => { + const dy = Array3D.new([2, 2, 2], [1, 44, 2, 33, 3, 22, 4, 11]); + const x = Array3D.new( + [3, 3, 2], + [1, 99, 2, 55, 3, 66, 4, 66, 5, 88, 6, 44, 7, 99, 8, 55, 9, 100]); + const expected = new Float32Array( + [0, 44, 0, 0, 0, 0, 0, 0, 1, 33, 2, 0, 0, 22, 3, 0, 4, 11]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + + expect(dx.inGPU()).toBe(true); + expect(dx.getValues()).toEqual(expected); + + dy.dispose(); + x.dispose(); + dx.dispose(); + }); + + it('x=3x3x2, f=2, s=1 duplicate max value', () => { + const dy = Array3D.new([2, 2, 2], [1, 44, 2, 33, 3, 22, 4, 11]); + const x = Array3D.new( + [3, 3, 2], [0, 1, 0, 3, 0, 2, 0, 1, 5, 2, 0, 1, 0, 1, 0, 1, 0, 5]); + const expected = new Float32Array( + [0, 0, 0, 77, 0, 0, 0, 0, 10, 22, 0, 0, 0, 0, 0, 0, 0, 11]); + const dx = math.maxPoolBackprop(dy, x, 2, 1, 0); + + expect(dx.inGPU()).toBe(true); + expect(dx.getValues()).toEqual(expected); + + dy.dispose(); + x.dispose(); + dx.dispose(); + }); +}); + +describe('NDArrayMathGPU resizeBilinear', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.dispose(); + }); + + it('simple alignCorners=false', () => { + const input = Array3D.new([2, 2, 1], [2, 2, 4, 4]); + const output = math.resizeBilinear3D(input, [3, 3], false); + + test_util.expectArraysClose( + output.getValues(), + new Float32Array([2, 2, 2, 10 / 3, 10 / 3, 10 / 3, 4, 4, 4]), 1e-4); + input.dispose(); + }); + + it('simple alignCorners=true', () => { + const input = Array3D.new([2, 2, 1], [2, 2, 4, 4]); + const output = math.resizeBilinear3D(input, [3, 3], true); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([2, 2, 2, 3, 3, 3, 4, 4, 4]), + 1e-4); + input.dispose(); + }); + + it('matches tensorflow w/ random numbers alignCorners=false', () => { + const input = Array3D.new([2, 3, 2], [ + 1.19074044, 0.91373104, 2.01611669, -0.52270832, 0.38725395, 1.30809779, + 0.61835143, 3.49600659, 2.09230986, 0.56473997, 0.03823943, 1.19864896 + ]); + const output = math.resizeBilinear3D(input, [4, 5], false); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([ + 1.19074047, 0.91373104, 1.68596613, 0.05186744, 1.69034398, + -0.15654698, 0.7130264, 0.94193673, 0.38725394, 1.30809784, + 0.9045459, 2.20486879, 1.59434628, 0.89455694, 1.68591988, + 0.26748738, 0.58103991, 1.00690198, 0.21274668, 1.25337338, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893 + ]), + 1e-4); + input.dispose(); + }); + + it('matches tensorflow w/ random numbers alignCorners=true', () => { + const input = Array3D.new([2, 3, 2], [ + 1.56324531, 2.13817752, 1.44398421, 1.07632684, 0.59306785, -0.36970865, + 1.62451879, 1.8367334, 1.13944798, 2.01993218, 2.01919952, 2.67524054 + ]); + const output = math.resizeBilinear3D(input, [4, 5], true); + + test_util.expectArraysClose( + output.getValues(), new Float32Array([ + 1.5632453, 2.13817763, 1.50361478, 1.60725224, 1.44398427, + 1.07632685, 1.01852608, 0.35330909, 0.59306782, -0.36970866, + 1.58366978, 2.03769612, 1.46307099, 1.71427906, 1.3424722, + 1.39086199, 1.20545864, 1.01806819, 1.06844509, 0.6452744, + 1.60409427, 1.93721485, 1.42252707, 1.82130599, 1.24096, + 1.70539713, 1.3923912, 1.68282723, 1.54382229, 1.66025746, + 1.62451875, 1.83673346, 1.38198328, 1.92833281, 1.13944793, + 2.01993227, 1.57932377, 2.34758639, 2.01919961, 2.67524052 + ]), + 1e-4); + + input.dispose(); + }); +}); + +describe('NDArrayMathGPU batchNorm', () => { + let math: NDArrayMathGPU; + beforeEach(() => { + math = new NDArrayMathGPU(); + math.startScope(); + }); + + afterEach(() => { + math.endScope(null!); + math.startScope(); + }); + + it('simple batchnorm, no offset or scale, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, undefined, undefined); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + (x.get(0, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(0, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon), + (x.get(1, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(1, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-4); + x.dispose(); + mean.dispose(); + variance.dispose(); + }); + + it('simple batchnorm, no offset, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const scale = Array1D.new([4, 5]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, undefined); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + (x.get(0, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(0, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon), + (x.get(1, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + (x.get(1, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-4); + x.dispose(); + mean.dispose(); + variance.dispose(); + scale.dispose(); + }); + + it('simple batchnorm, no scale, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const offset = Array1D.new([4, 5]); + + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, undefined, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + offset.get(0) + + (x.get(0, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(0, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon), + offset.get(0) + + (x.get(1, 0, 0) - mean.get(0)) * 1 / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(1, 0, 1) - mean.get(1)) * 1 / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-4); + x.dispose(); + mean.dispose(); + variance.dispose(); + offset.dispose(); + }); + + it('simple batchnorm, 2x1x2', () => { + const x = Array3D.new([2, 1, 2], new Float32Array([2, 100, 4, 400])); + const mean = Array1D.new([1, 2]); + const variance = Array1D.new([2, 3]); + const offset = Array1D.new([3, 4]); + const scale = Array1D.new([4, 5]); + + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + offset.get(0) + + (x.get(0, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(0, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon), + offset.get(0) + + (x.get(1, 0, 0) - mean.get(0)) * scale.get(0) / + Math.sqrt(variance.get(0) + varianceEpsilon), + offset.get(1) + + (x.get(1, 0, 1) - mean.get(1)) * scale.get(1) / + Math.sqrt(variance.get(1) + varianceEpsilon) + ]), + 1e-4); + x.dispose(); + mean.dispose(); + variance.dispose(); + scale.dispose(); + offset.dispose(); + }); + + it('batchnorm matches tensorflow, 2x3x3', () => { + const x = + Array3D.new([2, 3, 3], new Float32Array([ + 0.49955603, 0.04158615, -1.09440524, 2.03854165, + -0.61578344, 2.87533573, 1.18105987, 0.807462, 1.87888837, + 2.26563962, -0.37040935, 1.35848753, -0.75347094, + 0.15683117, 0.91925946, 0.34121279, 0.92717143, 1.89683965 + ])); + const mean = Array1D.new([0.39745062, -0.48062894, 0.4847822]); + const variance = Array1D.new([0.32375343, 0.67117643, 1.08334653]); + const offset = Array1D.new([0.69398749, -1.29056387, 0.9429723]); + const scale = Array1D.new([-0.5607271, 0.9878457, 0.25181573]); + const varianceEpsilon = .001; + + const result = math.batchNormalization3D( + x, mean, variance, varianceEpsilon, scale, offset); + + test_util.expectArraysClose( + result.getValues(), new Float32Array([ + 0.59352049, -0.66135202, 0.5610874, -0.92077015, -1.45341019, + 1.52106473, -0.07704776, 0.26144429, 1.28010017, -1.14422404, + -1.15776136, 1.15425493, 1.82644104, -0.52249442, 1.04803919, + 0.74932291, 0.40568101, 1.2844412 + ]), + 1e-4); + x.dispose(); + mean.dispose(); + variance.dispose(); + scale.dispose(); + offset.dispose(); + }); +}); diff --git a/src/math/ndarray.ts b/src/math/ndarray.ts new file mode 100644 index 0000000000..d12b293b62 --- /dev/null +++ b/src/math/ndarray.ts @@ -0,0 +1,569 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../util'; + +import {GPGPUContext} from './webgl/gpgpu_context'; +import {TextureManager} from './webgl/texture_manager'; +import * as webgl_util from './webgl/webgl_util'; + +// These global variables need to be initialized to null so that closure knows +// not to seal them. +/** @hidden */ +export let GPGPU: GPGPUContext = null!; +/** @hidden */ +export let TEXTURE_MANAGER: TextureManager = null!; + +/** @hidden */ +export interface NDArrayData { + values?: Float32Array; + texture?: WebGLTexture; + /** [rows, columns] shape of the texture. */ + textureShapeRC?: [number, number]; +} + +/** @hidden */ +export function initializeGPU( + gpgpu: GPGPUContext, textureManager: TextureManager) { + GPGPU = gpgpu; + TEXTURE_MANAGER = textureManager; +} + +function throwIfGPUNotInitialized() { + if (GPGPU == null || TEXTURE_MANAGER == null) { + throw new Error('GPU not intialized.'); + } +} + +export class NDArray { + /** The shape of the ndarray. */ + shape: number[]; + /** Number of elements in the ndarray. */ + size: number; + + /** + * Number of elements to skip in each dimension when indexing. See + * https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.strides.html + */ + protected strides: number[]; + + private data: NDArrayData; + + protected constructor(shape: number[], data: NDArrayData) { + // Sanity checks. + util.assert( + data.values != null || data.texture != null, + 'Either `values` or `texture` must be defined'); + + util.assert( + data.texture == null || (data.textureShapeRC != null), + '`textureShape` must be defined when `texture` is defined'); + + this.size = util.sizeFromShape(shape); + + if (data.values != null) { + util.assert( + this.size === data.values.length, + 'Constructing ndarray of shape (' + this.size + ') should match the' + + ' length of values (' + data.values.length + ')'); + } + + this.shape = shape; + this.data = data; + const dim = this.shape.length; + + if (dim < 2) { + this.strides = []; + } else { + // Last dimension has implicit stride of 1, thus having D-1 (instead of D) + // strides. + this.strides = new Array(dim - 1); + this.strides[dim - 2] = this.shape[dim - 1]; + for (let i = dim - 3; i >= 0; --i) { + this.strides[i] = this.strides[i + 1] * this.shape[i + 1]; + } + } + } + + /** Creates a ndarray of zeros with the specified shape. */ + static zeros(shape: number[]): T { + const values = new Float32Array(util.sizeFromShape(shape)); + return NDArray.make(shape, {values}); + } + + /** Creates a ndarray of zeros with the same shape as the specified ndarray. + */ + static zerosLike(another: T): T { + return NDArray.zeros(another.shape) as T; + } + + /** Creates a ndarray with the same values/shape as the specified ndarray. */ + static like(another: T): T { + const values = another.getValues(); + return NDArray.make(another.shape, {values: new Float32Array(values)}); + } + + /** + * Makes a new ndarray with the provided shape and values. Values should be in + * a flat array. + */ + static make(shape: number[], data: NDArrayData): T { + switch (shape.length) { + case 0: + return new Scalar(data) as T; + case 1: + // tslint:disable-next-line:no-any + return new Array1D(data) as any; + case 2: + // tslint:disable-next-line:no-any + return new Array2D(shape as [number, number], data) as any; + case 3: + // tslint:disable-next-line:no-any + return new Array3D(shape as [number, number, number], data) as any; + case 4: + return new Array4D( + // tslint:disable-next-line:no-any + shape as [number, number, number, number], data) as any; + default: + // tslint:disable-next-line:no-any + return new NDArray(shape, data) as any; + } + } + + /** Reshapes the current ndarray into the provided shape. */ + reshape(newShape: number[]): T { + if (util.arraysEqual(this.shape, newShape)) { + // No-op. + // tslint:disable-next-line:no-any + return this as any; + } + + util.assert( + this.size === util.sizeFromShape(newShape), + 'new shape and old shape must have the same number of elements.'); + + return NDArray.make(newShape, this.data); + } + + asScalar(): Scalar { + util.assert(this.size === 1, 'The array must have only 1 element.'); + return this.reshape([]); + } + + as1D(): Array1D { + return this.reshape([this.size]); + } + + as2D(rows: number, columns: number): Array2D { + return this.reshape([rows, columns]); + } + + as3D(rows: number, columns: number, depth: number): Array3D { + return this.reshape([rows, columns, depth]); + } + + as4D(rows: number, columns: number, depth: number, depth2: number): Array4D { + return this.reshape([rows, columns, depth, depth2]); + } + + get rank(): number { + return this.shape.length; + } + + get(...locs: number[]) { + let index = locs[locs.length - 1]; + for (let i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return this.getValues()[index]; + } + + add(value: number, ...locs: number[]) { + this.set(this.get(...locs) + value, ...locs); + } + + set(value: number, ...locs: number[]) { + let index = locs[locs.length - 1]; + for (let i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + this.getValues()[index] = value; + } + + locToIndex(locs: number[]): number { + let index = locs[locs.length - 1]; + for (let i = 0; i < locs.length - 1; ++i) { + index += this.strides[i] * locs[i]; + } + return index; + } + + indexToLoc(index: number): number[] { + const locs: number[] = new Array(this.shape.length); + for (let i = 0; i < locs.length - 1; ++i) { + locs[i] = Math.floor(index / this.strides[i]); + index -= locs[i] * this.strides[i]; + } + locs[locs.length - 1] = index; + return locs; + } + + fill(value: number) { + this.getValues().fill(value); + } + + getData(): NDArrayData { + return this.data; + } + + getValues(): Float32Array { + if (this.data.values == null) { + throwIfGPUNotInitialized(); + this.data.values = GPGPU.downloadMatrixFromTexture( + this.data.texture!, this.data.textureShapeRC![0], + this.data.textureShapeRC![1]); + this.disposeTexture(); + } + return this.data.values; + } + + private uploadToGPU(preferredTexShape?: [number, number]) { + throwIfGPUNotInitialized(); + this.data.textureShapeRC = webgl_util.getTextureShapeFromLogicalShape( + GPGPU.gl, this.shape, preferredTexShape); + this.data.texture = + TEXTURE_MANAGER.acquireTexture(this.data.textureShapeRC); + + GPGPU.uploadMatrixToTexture( + this.data.texture, this.data.textureShapeRC[0], + this.data.textureShapeRC[1], this.data.values!); + + this.data.values = null!; + } + + getTexture(preferredShapeRC?: [number, number]): WebGLTexture { + if (this.data.texture == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.texture!; + } + + getTextureShapeRC(preferredShapeRC?: [number, number]): [number, number] { + if (this.data.textureShapeRC == null) { + this.uploadToGPU(preferredShapeRC); + } + return this.data.textureShapeRC!; + } + + dispose(): void { + this.data.values = null!; + this.shape = null!; + if (this.data.texture != null) { + this.disposeTexture(); + } + } + + private disposeTexture() { + throwIfGPUNotInitialized(); + TEXTURE_MANAGER.releaseTexture( + this.data.texture!, this.data.textureShapeRC!); + this.data.texture = null!; + this.data.textureShapeRC = null!; + } + + inGPU(): boolean { + return this.data.texture != null; + } + + equals(t: NDArray): boolean { + return util.arraysEqual(this.shape, t.shape) && + util.arraysEqual(this.getValues(), t.getValues()); + } + + static rand(shape: number[], randFunction: () => number): + T { + const size = util.sizeFromShape(shape); + const values = new Float32Array(size); + for (let i = 0; i < size; i++) { + values[i] = randFunction(); + } + + return NDArray.make(shape, {values}); + } + + static randNormal(shape: number[], mean = 0, stdDev = 1) { + return NDArray.rand(shape, () => util.randGauss(mean, stdDev)); + } + + static randTruncatedNormal( + shape: number[], mean = 0, stdDev = 1) { + return NDArray.rand(shape, () => util.randGauss(mean, stdDev, true)); + } + + static randUniform(shape: number[], a: number, b: number) { + return NDArray.rand(shape, () => util.randUniform(a, b)); + } +} + +export class Scalar extends NDArray { + constructor(data: NDArrayData) { + if (data.texture != null) { + data.textureShapeRC = [1, 1]; + } + super([], data); + } + + static new(value: number) { + return new Scalar({values: new Float32Array([value])}); + } + + static ZERO = Scalar.new(0); + static ONE = Scalar.new(1); + static TWO = Scalar.new(2); + static NEG_ONE = Scalar.new(-1); + + get(): number { + return this.getValues()[0]; + } + + set(value: number) { + this.getValues()[0] = value; + } + + add(value: number) { + this.getValues()[0] += value; + } +} + +export class Array1D extends NDArray { + shape: [number]; + + constructor(data: NDArrayData) { + const shape = (data.values != null) ? + [data.values.length] : + [util.sizeFromShape(data.textureShapeRC!)]; + super(shape, data); + } + + static new(values: Float32Array|number[]) { + if (!(values instanceof Float32Array)) { + const inferredShape = util.inferShape(values); + util.assert( + inferredShape.length === 1, + `Error constructing Array1D. Shape of values ${inferredShape} is ` + + `not 1 dimensional.`); + } + return new Array1D({values: toTypedArray(values)}); + } + + get(i: number): number { + return this.getValues()[i]; + } + + set(value: number, i: number) { + this.getValues()[i] = value; + } + + add(value: number, i: number) { + this.getValues()[i] += value; + } + + locToIndex(loc: [number]): number { + return loc[0]; + } + + indexToLoc(index: number): [number] { + return [index]; + } + + static zeros(shape: [number]): Array1D { + return NDArray.zeros(shape); + } +} + +export class Array2D extends NDArray { + shape: [number, number]; + + private stride0: number; + + constructor(shape: [number, number], data: NDArrayData) { + util.assert(shape.length === 2, 'Shape should be of length 2'); + super(shape, data); + this.stride0 = this.strides[0]; + } + + static new( + shape: [number, number], values: Float32Array|number[]|number[][]) { + if (!(values instanceof Float32Array)) { + const inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch( + shape, inferredShape, + `Error when constructing Array2D. Shape of values ` + + `${inferredShape} does not match the provided shape ` + + `${shape}. `); + } + } + return new Array2D(shape, {values: toTypedArray(values)}); + } + + get(i: number, j: number) { + return this.getValues()[this.stride0 * i + j]; + } + + set(value: number, i: number, j: number) { + this.getValues()[this.stride0 * i + j] = value; + } + + add(value: number, i: number, j: number) { + this.getValues()[this.stride0 * i + j] += value; + } + + locToIndex(locs: [number, number]): number { + return this.stride0 * locs[0] + locs[1]; + } + + indexToLoc(index: number): [number, number] { + return [Math.floor(index / this.stride0), index % this.stride0]; + } + + static zeros(shape: [number, number]): Array2D { + return NDArray.zeros(shape); + } +} + +export class Array3D extends NDArray { + shape: [number, number, number]; + private stride0: number; + private stride1: number; + + constructor(shape: [number, number, number], data: NDArrayData) { + util.assert(shape.length === 3, 'Shape should be of length 3'); + super(shape, data); + this.stride0 = this.strides[0]; + this.stride1 = this.strides[1]; + } + + static new( + shape: [number, number, number], + values: Float32Array|number[]|number[][][]) { + if (!(values instanceof Float32Array)) { + const inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch( + shape, inferredShape, + `Error when constructing Array3D. Shape of values ` + + `${inferredShape} does not match the provided shape ` + + `${shape}. `); + } + } + return new Array3D(shape, {values: toTypedArray(values)}); + } + + get(i: number, j: number, k: number) { + return this.getValues()[this.stride0 * i + this.stride1 * j + k]; + } + + set(value: number, i: number, j: number, k: number) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] = value; + } + + add(value: number, i: number, j: number, k: number) { + this.getValues()[this.stride0 * i + this.stride1 * j + k] += value; + } + + locToIndex(locs: [number, number, number]): number { + return this.stride0 * locs[0] + this.stride1 * locs[1] + locs[2]; + } + + indexToLoc(index: number): [number, number, number] { + const i = Math.floor(index / this.stride0); + index -= i * this.stride0; + return [i, Math.floor(index / this.stride1), index % this.stride1]; + } + + static zeros(shape: [number, number, number]): Array3D { + return NDArray.zeros(shape); + } +} + +export class Array4D extends NDArray { + shape: [number, number, number, number]; + private stride0: number; + private stride1: number; + private stride2: number; + + constructor(shape: [number, number, number, number], data: NDArrayData) { + util.assert(shape.length === 4, 'Shape should be of length 4'); + super(shape, data); + this.stride0 = this.strides[0]; + this.stride1 = this.strides[1]; + this.stride2 = this.strides[2]; + } + + static new( + shape: [number, number, number, number], + values: Float32Array|number[]|number[][][][]) { + if (!(values instanceof Float32Array)) { + const inferredShape = util.inferShape(values); + if (inferredShape.length > 1) { + util.assertShapesMatch( + shape, inferredShape, + `Error when constructing Array4D. Shape of values ` + + `${inferredShape} does not match the provided shape ` + + `${shape}. `); + } + } + return new Array4D(shape, {values: toTypedArray(values)}); + } + + get(i: number, j: number, k: number, l: number) { + return this.getValues() + [this.stride0 * i + this.stride1 * j + this.stride2 * k + l]; + } + + set(value: number, i: number, j: number, k: number, l: number) { + this.getValues() + [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] = value; + } + + add(value: number, i: number, j: number, k: number, l: number) { + this.getValues() + [this.stride0 * i + this.stride1 * j + this.stride2 * k + l] += value; + } + + locToIndex(locs: [number, number, number, number]): number { + return this.stride0 * locs[0] + this.stride1 * locs[1] + + this.stride2 * locs[2] + locs[3]; + } + + indexToLoc(index: number): [number, number, number, number] { + const i = Math.floor(index / this.stride0); + index -= i * this.stride0; + const j = Math.floor(index / this.stride1); + index -= j * this.stride1; + return [i, j, Math.floor(index / this.stride2), index % this.stride2]; + } + + static zeros(shape: [number, number, number, number]): Array4D { + return NDArray.zeros(shape); + } +} + +type ArrayData = Float32Array|number[]|number[][]|number[][][]|number[][][][]; + +function toTypedArray(a: ArrayData): Float32Array { + return (a instanceof Float32Array) ? a : new Float32Array(util.flatten(a)); +} diff --git a/src/math/ndarray_test.ts b/src/math/ndarray_test.ts new file mode 100644 index 0000000000..b8f8604fce --- /dev/null +++ b/src/math/ndarray_test.ts @@ -0,0 +1,338 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as ndarray from './ndarray'; +import {Array1D, Array2D, Array3D, Array4D, GPGPU, NDArray, Scalar, TEXTURE_MANAGER} from './ndarray'; +import {GPGPUContext} from './webgl/gpgpu_context'; +import * as gpgpu_util from './webgl/gpgpu_util'; +import {TextureManager} from './webgl/texture_manager'; + +describe('NDArray', () => { + let gl: WebGLRenderingContext; + let gpgpu: GPGPUContext; + let textureManager: TextureManager; + + beforeEach(() => { + gl = gpgpu_util.createWebGLContext(); + gpgpu = new GPGPUContext(gl); + textureManager = new TextureManager(gpgpu); + ndarray.initializeGPU(gpgpu, textureManager); + }); + + afterEach(() => { + textureManager.dispose(); + gpgpu.dispose(); + }); + + it('NDArrays of arbitrary size', () => { + // [1, 2, 3] + let t: NDArray = Array1D.new([1, 2, 3]); + expect(t instanceof Array1D).toBe(true); + expect(t.rank).toBe(1); + expect(t.size).toBe(3); + expect(t.getValues()).toEqual(new Float32Array([1, 2, 3])); + expect(t.get(0)).toBe(1); + expect(t.get(1)).toBe(2); + expect(t.get(2)).toBe(3); + // Out of bounds indexing. + expect(t.get(4)).toBeUndefined(); + + // [[1, 2, 3]] + t = Array2D.new([1, 3], [1, 2, 3]); + expect(t instanceof Array2D).toBe(true); + expect(t.rank).toBe(2); + expect(t.size).toBe(3); + expect(t.get(0, 0)).toBe(1); + expect(t.get(0, 1)).toBe(2); + expect(t.get(0, 2)).toBe(3); + // Out of bounds indexing. + expect(t.get(4)).toBeUndefined(); + + // [[1, 2, 3], + // [4, 5, 6]] + t = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + expect(t instanceof Array2D).toBe(true); + expect(t.rank).toBe(2); + expect(t.size).toBe(6); + expect(t.get(0, 0)).toBe(1); + expect(t.get(0, 1)).toBe(2); + expect(t.get(0, 2)).toBe(3); + expect(t.get(1, 0)).toBe(4); + expect(t.get(1, 1)).toBe(5); + expect(t.get(1, 2)).toBe(6); + // Out of bounds indexing. + expect(t.get(5, 3)).toBeUndefined(); + + // Shape mismatch with the values. + expect(() => Array2D.new([1, 2], [1])).toThrowError(); + }); + + it('NDArrays of explicit size', () => { + const t = Array1D.new([5, 3, 2]); + expect(t.rank).toBe(1); + expect(t.shape).toEqual([3]); + expect(t.get(1)).toBe(3); + + expect(() => Array3D.new([1, 2, 3, 5], [ + 1, 2 + ])).toThrowError('Shape should be of length 3'); + + const t4 = Array4D.new([1, 2, 1, 2], [1, 2, 3, 4]); + expect(t4.get(0, 0, 0, 0)).toBe(1); + expect(t4.get(0, 0, 0, 1)).toBe(2); + expect(t4.get(0, 1, 0, 0)).toBe(3); + expect(t4.get(0, 1, 0, 1)).toBe(4); + + const t4Like = NDArray.like(t4); + // Change t4. + t4.set(10, 0, 0, 0, 1); + expect(t4.get(0, 0, 0, 1)).toBe(10); + // Make suree t4_like hasn't changed. + expect(t4Like.get(0, 0, 0, 1)).toBe(2); + + // NDArray of zeros. + const z = NDArray.zeros([3, 4, 2]) as Array3D; + expect(z.rank).toBe(3); + expect(z.size).toBe(24); + for (let i = 0; i < 3; i++) { + for (let j = 0; j < 4; j++) { + for (let k = 0; k < 2; k++) { + expect(z.get(i, j, k)).toBe(0); + } + } + } + + // Reshaping ndarrays. + const a = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const b = a.reshape([3, 2, 1]); + expect(a.get(1, 2)).toBe(6); + + // Modify the reshaped ndarray. + b.set(10, 2, 1, 0); + // Make sure the original ndarray is also modified. + expect(a.get(1, 2)).toBe(10); + }); + + it('NDArray CPU --> GPU', () => { + const a = Array2D.new([3, 2], [1, 2, 3, 4, 5, 6]); + + expect(a.inGPU()).toBe(false); + + expect(a.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + + expect(a.inGPU()).toBe(false); + + // Upload to GPU. + expect(a.getTexture() != null).toBe(true); + + expect(a.inGPU()).toBe(true); + a.dispose(); + }); + + it('NDArray GPU --> CPU', () => { + const texture = textureManager.acquireTexture([3, 2]); + gpgpu.uploadMatrixToTexture( + texture, 3, 2, new Float32Array([1, 2, 3, 4, 5, 6])); + + const a = new Array2D([3, 2], {texture, textureShapeRC: [3, 2]}); + expect(a.inGPU()).toBe(true); + + expect(a.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + expect(a.inGPU()).toBe(false); + }); + + it('Scalar basic methods', () => { + const a = Scalar.new(5); + expect(a.get()).toBe(5); + expect(a.getValues()).toEqual(new Float32Array([5])); + expect(a.rank).toBe(0); + expect(a.size).toBe(1); + expect(a.shape).toEqual([]); + }); + + it('Scalar in GPU', () => { + const texture = textureManager.acquireTexture([1, 1]); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([10])); + + const a = new Scalar({texture}); + expect(a.inGPU()).toBe(true); + expect(a.getValues()).toEqual(new Float32Array([10])); + expect(a.inGPU()).toBe(false); + }); + + it('Array1D in GPU', () => { + const texture = textureManager.acquireTexture([1, 3]); + gpgpu.uploadMatrixToTexture(texture, 1, 3, new Float32Array([10, 7, 3])); + + const a = new Array1D({texture, textureShapeRC: [1, 3]}); + expect(a.inGPU()).toBe(true); + expect(a.getValues()).toEqual(new Float32Array([10, 7, 3])); + expect(a.inGPU()).toBe(false); + }); + + it('Array1D in GPU, but incorrect c-tor (missing textureShape)', () => { + const texture = textureManager.acquireTexture([1, 3]); + gpgpu.uploadMatrixToTexture(texture, 1, 3, new Float32Array([10, 7, 3])); + + const f = () => { + return new Array1D({texture}); + }; + + expect(f).toThrowError(); + textureManager.releaseTexture(texture, [1, 3]); + }); + + it('NDArray.make() constructs a Scalar', () => { + const a = NDArray.make([], {values: new Float32Array([3])}); + expect(a instanceof Scalar).toBe(true); + }); + + it('Array2D in GPU, reshaped to Array1D', () => { + const texture = textureManager.acquireTexture([2, 2]); + gpgpu.uploadMatrixToTexture(texture, 2, 2, new Float32Array([10, 7, 3, 5])); + + const a = new Array2D([2, 2], {texture, textureShapeRC: [2, 2]}); + const a1d = a.as1D(); + + expect(a1d.getValues()).toEqual(new Float32Array([10, 7, 3, 5])); + }); + + it('Array1D in GPU, reshaped to Array2D', () => { + const texture = textureManager.acquireTexture([1, 4]); + gpgpu.uploadMatrixToTexture(texture, 1, 4, new Float32Array([10, 7, 3, 5])); + + const a = new Array1D({texture, textureShapeRC: [1, 4]}); + const a2d = a.as2D(2, 2); + + expect(a2d.getValues()).toEqual(new Float32Array([10, 7, 3, 5])); + }); + + it('Array2D in GPU with custom texture shape', () => { + const texture = textureManager.acquireTexture([4, 1]); + gpgpu.uploadMatrixToTexture(texture, 4, 1, new Float32Array([10, 7, 3, 5])); + + const a = new Array2D([2, 2], {texture, textureShapeRC: [4, 1]}); + + expect(a.getValues()).toEqual(new Float32Array([10, 7, 3, 5])); + }); + + it('index2Loc Array1D', () => { + const t = Array1D.zeros([3]); + expect(t.indexToLoc(0)).toEqual([0]); + expect(t.indexToLoc(1)).toEqual([1]); + expect(t.indexToLoc(2)).toEqual([2]); + }); + + it('index2Loc Array2D', () => { + const t = Array2D.zeros([3, 2]); + expect(t.indexToLoc(0)).toEqual([0, 0]); + expect(t.indexToLoc(1)).toEqual([0, 1]); + expect(t.indexToLoc(2)).toEqual([1, 0]); + expect(t.indexToLoc(3)).toEqual([1, 1]); + expect(t.indexToLoc(4)).toEqual([2, 0]); + expect(t.indexToLoc(5)).toEqual([2, 1]); + }); + + it('index2Loc Array3D', () => { + const t = Array2D.zeros([3, 2, 2]); + expect(t.indexToLoc(0)).toEqual([0, 0, 0]); + expect(t.indexToLoc(1)).toEqual([0, 0, 1]); + expect(t.indexToLoc(2)).toEqual([0, 1, 0]); + expect(t.indexToLoc(3)).toEqual([0, 1, 1]); + expect(t.indexToLoc(4)).toEqual([1, 0, 0]); + expect(t.indexToLoc(5)).toEqual([1, 0, 1]); + expect(t.indexToLoc(11)).toEqual([2, 1, 1]); + }); + + it('index2Loc NDArray 5D', () => { + const values = new Float32Array([1, 2, 3, 4]); + const t = NDArray.make([2, 1, 1, 1, 2], {values}); + expect(t.indexToLoc(0)).toEqual([0, 0, 0, 0, 0]); + expect(t.indexToLoc(1)).toEqual([0, 0, 0, 0, 1]); + expect(t.indexToLoc(2)).toEqual([1, 0, 0, 0, 0]); + expect(t.indexToLoc(3)).toEqual([1, 0, 0, 0, 1]); + }); + + it('preferred texture shape, Scalar', () => { + const t = Scalar.new(1); + expect(t.getTextureShapeRC()).toEqual([1, 1]); + }); + + it('preferred texture shape, Array1D column vector', () => { + const t = Array1D.zeros([4]); + expect(t.getTextureShapeRC()).toEqual([4, 1]); + }); + + it('preferred texture shape, Array2D same shape', () => { + const t = Array2D.zeros([5, 2]); + expect(t.getTextureShapeRC()).toEqual([5, 2]); + }); + + it('preferred texture shape, Array3D depth strided along columns', () => { + const t = Array3D.zeros([2, 2, 2]); + expect(t.getTextureShapeRC()).toEqual([2, 4]); + }); + + it('preferred texture shape, Array4D is squareish', () => { + const t = Array4D.zeros([8, 2, 4, 4]); + expect(t.getTextureShapeRC()).toEqual([16, 16]); + }); +}); // Close describe. + +describe('NDArray.new method', () => { + it('Array1D.new() from number[]', () => { + const a = Array1D.new([1, 2, 3]); + expect(a.getValues()).toEqual(new Float32Array([1, 2, 3])); + }); + + it('Array1D.new() from number[][], shape mismatch', () => { + // tslint:disable-next-line:no-any + expect(() => Array1D.new([[1], [2], [3]] as any)).toThrowError(); + }); + + it('Array2D.new() from number[][]', () => { + const a = Array2D.new([2, 3], [[1, 2, 3], [4, 5, 6]]); + expect(a.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('Array2D.new() from number[][], but shape does not match', () => { + // Actual shape is [2, 3]. + expect(() => Array2D.new([3, 2], [[1, 2, 3], [4, 5, 6]])).toThrowError(); + }); + + it('Array3D.new() from number[][][]', () => { + const a = Array3D.new([2, 3, 1], [[[1], [2], [3]], [[4], [5], [6]]]); + expect(a.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('Array3D.new() from number[][][], but shape does not match', () => { + const values = [[[1], [2], [3]], [[4], [5], [6]]]; + // Actual shape is [2, 3, 1]. + expect(() => Array3D.new([3, 2, 1], values)).toThrowError(); + }); + + it('Array4D.new() from number[][][][]', () => { + const a = Array4D.new([2, 2, 1, 1], [[[[1]], [[2]]], [[[4]], [[5]]]]); + expect(a.getValues()).toEqual(new Float32Array([1, 2, 4, 5])); + }); + + it('Array4D.new() from number[][][][], but shape does not match', () => { + const f = () => { + // Actual shape is [2, 2, 1, 1]. + Array4D.new([2, 1, 2, 1], [[[[1]], [[2]]], [[[4]], [[5]]]]); + }; + expect(f).toThrowError(); + }); +}); diff --git a/src/math/webgl/addscaledmat_gpu.ts b/src/math/webgl/addscaledmat_gpu.ts new file mode 100644 index 0000000000..57dee24ad6 --- /dev/null +++ b/src/math/webgl/addscaledmat_gpu.ts @@ -0,0 +1,84 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource(): string { + return ` + precision highp float; + uniform sampler2D matrixA; + uniform sampler2D matrixB; + uniform sampler2D matrixAScalar; + uniform sampler2D matrixBScalar; + varying vec2 resultUV; + + const vec2 halfTexel = vec2(0.5, 0.5); + + void main() { + float a = texture2D(matrixA, resultUV).r; + float b = texture2D(matrixB, resultUV).r; + float aScalar = texture2D(matrixAScalar, halfTexel).r; + float bScalar = texture2D(matrixBScalar, halfTexel).r; + vec2 abScaled = vec2(a, b) * vec2(aScalar, bScalar); + gl_FragColor = vec4(abScaled.x + abScaled.y, 0, 0, 0); + }`; +} + +export function addScaledMatrices( + gpgpu: GPGPUContext, addScaledMatricesProgram: WebGLProgram, + a: WebGLTexture, b: WebGLTexture, rows: number, columns: number, + aScalar: WebGLTexture, bScalar: WebGLTexture, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(addScaledMatricesProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.setInputMatrixTexture(aScalar, 'matrixAScalar', 2); + gpgpu.setInputMatrixTexture(bScalar, 'matrixBScalar', 3); + gpgpu.executeProgram(); +} + +export function uploadAddScaledMatricesDownload( + a: Float32Array, b: Float32Array, rows: number, columns: number, + aScalar: number, bScalar: number): Float32Array { + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource()); + + const aTex = gpgpu.createMatrixTexture(rows, columns); + const bTex = gpgpu.createMatrixTexture(rows, columns); + const aScalarTex = gpgpu.createMatrixTexture(1, 1); + const bScalarTex = gpgpu.createMatrixTexture(1, 1); + const resultTex = gpgpu.createMatrixTexture(rows, columns); + + gpgpu.uploadMatrixToTexture(aTex, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTex, rows, columns, b); + gpgpu.uploadMatrixToTexture(aScalarTex, 1, 1, new Float32Array([aScalar])); + gpgpu.uploadMatrixToTexture(bScalarTex, 1, 1, new Float32Array([bScalar])); + + addScaledMatrices( + gpgpu, program, aTex, bTex, rows, columns, aScalarTex, bScalarTex, + resultTex); + + const result = gpgpu.downloadMatrixFromTexture(resultTex, rows, columns); + + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteMatrixTexture(bTex); + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aScalarTex); + gpgpu.deleteMatrixTexture(bScalarTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return result; +} diff --git a/src/math/webgl/addscaledmat_gpu_test.ts b/src/math/webgl/addscaledmat_gpu_test.ts new file mode 100644 index 0000000000..617bb17383 --- /dev/null +++ b/src/math/webgl/addscaledmat_gpu_test.ts @@ -0,0 +1,75 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as addscaledmat_gpu from './addscaledmat_gpu'; + +function cpuAddScaledMatrices( + a: Float32Array, aScalar: number, b: Float32Array, + bScalar: number): Float32Array { + const result = new Float32Array(a.length); + for (let i = 0; i < result.length; ++i) { + result[i] = (a[i] * aScalar) + (b[i] * bScalar); + } + return result; +} + +describe('addscaledmat_gpu', () => { + it('returns a matrix with the same shape as the input matrices', () => { + const a = new Float32Array(9 * 14); + const b = new Float32Array(a.length); + const result = + addscaledmat_gpu.uploadAddScaledMatricesDownload(a, b, 9, 14, 0, 0); + expect(result.length).toEqual(9 * 14); + }); + + it('returns A + B when scalars are 1', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6]); + const result = + addscaledmat_gpu.uploadAddScaledMatricesDownload(a, b, 3, 2, 1, 1); + test_util.expectArraysClose( + result, new Float32Array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6]), 0.0001); + }); + + it('returns A * aScalar when B and bScalar are 0', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array(a.length); + const result = + addscaledmat_gpu.uploadAddScaledMatricesDownload(a, b, 3, 2, 1.1, 0); + test_util.expectArraysClose( + result, new Float32Array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6]), 0.0001); + }); + + it('returns B * bScalar when A and aScalar are 0', () => { + const b = new Float32Array([1, 2, 3, 4, 5, 6]); + const a = new Float32Array(b.length); + const result = + addscaledmat_gpu.uploadAddScaledMatricesDownload(a, b, 3, 2, 0, 1.1); + test_util.expectArraysClose( + result, new Float32Array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6]), 0.0001); + }); + + it('returns (A * aScalar) + (B * bScalar)', () => { + const a = test_util.randomArrayInRange(12 * 12, -2, 2); + const b = test_util.randomArrayInRange(a.length, -10, 10); + const aScalar = 0.5; + const bScalar = 0.25; + const result = addscaledmat_gpu.uploadAddScaledMatricesDownload( + a, b, 12, 12, aScalar, bScalar); + test_util.expectArraysClose( + result, cpuAddScaledMatrices(a, aScalar, b, bScalar), 0.001); + }); +}); diff --git a/src/math/webgl/addsubmuldiv_gpu.ts b/src/math/webgl/addsubmuldiv_gpu.ts new file mode 100644 index 0000000000..3ea00a7d92 --- /dev/null +++ b/src/math/webgl/addsubmuldiv_gpu.ts @@ -0,0 +1,116 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MatrixOrientation} from '../math'; + +import * as binaryop_gpu from './binaryop_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +export type Operation = '+' | '-' | '*' | '/'; + +export enum OperandType { + MATRIX, + SCALAR +} + +export function getFragmentShaderSource( + aType: OperandType, aOrientation: MatrixOrientation, op: Operation, + bType: OperandType, bOrientation: MatrixOrientation): string { + const aUV = operandToShaderSnippet(aType, aOrientation); + const bUV = operandToShaderSnippet(bType, bOrientation); + const resultOp = `gl_FragColor = vec4(a ${op} b, 0, 0, 0);`; + return binaryop_gpu.getFragmentShaderSource(aUV, bUV, resultOp); +} + +function operandToShaderSnippet( + operand: OperandType, orientation: MatrixOrientation): string { + switch (operand) { + case OperandType.MATRIX: + return 'resultUV' + + (orientation === MatrixOrientation.REGULAR ? '.st' : '.ts'); + case OperandType.SCALAR: + return 'vec2(0.5, 0.5)'; + default: + throw new Error('Unknown operand type'); + } +} + +export function addSubMulDiv( + gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, + aShapeRowCol: [number, number], b: WebGLTexture, + bShapeRowCol: [number, number], result: WebGLTexture, + resultShapeRowCol: [number, number]) { + return binaryop_gpu.binaryOp( + gpgpu, program, a, aShapeRowCol, b, bShapeRowCol, result, + resultShapeRowCol); +} + +export function uploadScalarPlusMatrixDownload( + a: number, b: Float32Array, bShape: [number, number], + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.SCALAR, MatrixOrientation.REGULAR, '+', OperandType.MATRIX, + bOrientation); + return binaryop_gpu.uploadBinaryOpDownload( + new Float32Array([a]), [1, 1], b, bShape, src); +} + +export function uploadMatrixMinusScalarDownload( + a: Float32Array, aShape: [number, number], b: number, + aOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.MATRIX, aOrientation, '-', OperandType.SCALAR, + MatrixOrientation.REGULAR); + return binaryop_gpu.uploadBinaryOpDownload( + a, aShape, new Float32Array([b]), [1, 1], src); +} + +export function uploadScalarMinusMatrixDownload( + a: number, b: Float32Array, bShape: [number, number], + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.SCALAR, MatrixOrientation.REGULAR, '-', OperandType.MATRIX, + bOrientation); + return binaryop_gpu.uploadBinaryOpDownload( + new Float32Array([a]), [1, 1], b, bShape, src); +} + +export function uploadScalarTimesMatrixDownload( + a: number, b: Float32Array, bShape: [number, number], + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.SCALAR, MatrixOrientation.REGULAR, '*', OperandType.MATRIX, + bOrientation); + return binaryop_gpu.uploadBinaryOpDownload( + new Float32Array([a]), [1, 1], b, bShape, src); +} + +export function uploadMatrixTimesMatrixDownload( + a: Float32Array, b: Float32Array, shape: [number, number], + aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.MATRIX, aOrientation, '*', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} + +export function uploadMatrixPlusMatrixDownload( + a: Float32Array, b: Float32Array, shape: [number, number], + aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const src = getFragmentShaderSource( + OperandType.MATRIX, aOrientation, '+', OperandType.MATRIX, bOrientation); + return binaryop_gpu.uploadBinaryOpDownload(a, shape, b, shape, src); +} diff --git a/src/math/webgl/addsubmuldiv_gpu_test.ts b/src/math/webgl/addsubmuldiv_gpu_test.ts new file mode 100644 index 0000000000..5087ce05c6 --- /dev/null +++ b/src/math/webgl/addsubmuldiv_gpu_test.ts @@ -0,0 +1,214 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import {MatrixOrientation} from '../math'; + +import * as addsubmuldiv_gpu from './addsubmuldiv_gpu'; + +describe('addsubmuldiv_gpu ScalarPlusMatrix', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(12 * 513); + const result = + addsubmuldiv_gpu.uploadScalarPlusMatrixDownload(0, a, [12, 513]); + expect(result.length).toEqual(a.length); + }); + + it('preserves the matrix when the scalar is 0', () => { + const a = new Float32Array([1, 2, 3]); + const result = + addsubmuldiv_gpu.uploadScalarPlusMatrixDownload(0, a, [1, 3]); + test_util.expectArraysClose(result, a, 0); + }); + + it('adds the scalar to every element in the matrix', () => { + const a = new Float32Array([1, 2, 3, 4]); + const result = + addsubmuldiv_gpu.uploadScalarPlusMatrixDownload(0.5, a, [2, 2]); + test_util.expectArraysClose( + result, new Float32Array([1.5, 2.5, 3.5, 4.5]), 0.0001); + }); +}); + +describe('addsubmuldiv_gpu MatrixMinusScalar', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(12 * 513); + const result = + addsubmuldiv_gpu.uploadMatrixMinusScalarDownload(a, [12, 513], 0); + expect(result.length).toEqual(a.length); + }); + + it('preserves the matrix when the scalar is 0', () => { + const a = new Float32Array([1, 2, 3]); + const result = + addsubmuldiv_gpu.uploadMatrixMinusScalarDownload(a, [1, 3], 0); + test_util.expectArraysClose(result, a, 0); + }); + + it('subtracts the scalar from every element in the matrix', () => { + const a = new Float32Array([1, 2, 3, 4]); + const result = + addsubmuldiv_gpu.uploadMatrixMinusScalarDownload(a, [2, 2], 0.5); + test_util.expectArraysClose( + result, new Float32Array([0.5, 1.5, 2.5, 3.5]), 0.0001); + }); +}); + +describe('addsubmuldiv_gpu ScalarMinusMatrix', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(12 * 513); + const result = + addsubmuldiv_gpu.uploadScalarMinusMatrixDownload(0, a, [12, 513]); + expect(result.length).toEqual(a.length); + }); + + it('negates the matrix when the scalar is 0', () => { + const a = new Float32Array([1, 2, 3]); + const result = + addsubmuldiv_gpu.uploadScalarMinusMatrixDownload(0, a, [1, 3]); + test_util.expectArraysClose(result, new Float32Array([-1, -2, -3]), 0); + }); + + it('subtracts the matrix value from the scalar for every element', () => { + const a = new Float32Array([1, 2, 3, 4]); + const result = + addsubmuldiv_gpu.uploadScalarMinusMatrixDownload(0.5, a, [2, 2]); + test_util.expectArraysClose( + result, new Float32Array([-0.5, -1.5, -2.5, -3.5]), 0.0001); + }); +}); + +describe('addsubmuldiv_gpu ScalarTimesMatrix', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(12 * 513); + const result = + addsubmuldiv_gpu.uploadScalarTimesMatrixDownload(0, a, [12, 513]); + expect(result.length).toEqual(a.length); + }); + + it('zeros out the matrix when the scalar is 0', () => { + const a = new Float32Array([1, 2, 3]); + const result = + addsubmuldiv_gpu.uploadScalarTimesMatrixDownload(0, a, [1, 3]); + test_util.expectArraysClose(result, new Float32Array([0, 0, 0]), 0); + }); + + it('triples the matrix when the scalar is 3', () => { + const a = new Float32Array([1, 2, 3]); + const result = + addsubmuldiv_gpu.uploadScalarTimesMatrixDownload(3, a, [1, 3]); + test_util.expectArraysClose(result, new Float32Array([3, 6, 9]), 0); + }); +}); + +describe('addsubmuldiv_gpu element-wise matrix product', () => { + function cpuMultiply(a: Float32Array, b: Float32Array): Float32Array { + const result = new Float32Array(a.length); + for (let i = 0; i < result.length; ++i) { + result[i] = a[i] * b[i]; + } + return result; + } + + it('returns a matrix the size of A (and B)', () => { + const a = new Float32Array(1234); + const b = new Float32Array(1234); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [1234 / 2, 2]); + expect(result.length).toEqual(a.length); + }); + + it('sets all result entries to 0 if A is 0', () => { + const a = new Float32Array(257 * 257); + const b = new Float32Array(a.length); + b.fill(1.0); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [257, 257]); + expect(result).toEqual(a); + }); + + it('sets all result entries to 0 if B is 0', () => { + const a = new Float32Array(257 * 257); + const b = new Float32Array(a.length); + a.fill(1.0); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [257, 257]); + expect(result).toEqual(b); + }); + + it('sets all result entries to A if B is [1]', () => { + const a = test_util.randomArrayInRange(16, -10, 10); + const b = new Float32Array(16); + b.fill(1.0); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [4, 4]); + test_util.expectArraysClose(a, result, 0.0001); + }); + + it('sets all result entries to B if A is [1]', () => { + const a = new Float32Array(16); + a.fill(1.0); + const b = test_util.randomArrayInRange(16, -10, 10); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [4, 4]); + test_util.expectArraysClose(b, result, 0.0001); + }); + + it('writes the element-wise product of A and B to result', () => { + const a = test_util.randomArrayInRange(64, -10, 10); + const b = test_util.randomArrayInRange(64, -10, 10); + const result = + addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload(a, b, [8, 8]); + const expected = cpuMultiply(a, b); + test_util.expectArraysClose(result, expected, 0.0001); + }); + + it('writes the element-wise product A * B^T to result', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array([3, 1, 0, 2]); + + const result = addsubmuldiv_gpu.uploadMatrixTimesMatrixDownload( + a, b, [2, 2], MatrixOrientation.REGULAR, MatrixOrientation.TRANSPOSED); + + const bTransposed = new Float32Array([3, 0, 1, 2]); + const expected = cpuMultiply(a, bTransposed); + test_util.expectArraysClose(result, expected, 0.0001); + }); +}); + +describe('addsubmuldiv_gpu element-wise matrix addition', () => { + it('writes the element-wise A + B^T to result', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array([3, 1, 0, 2]); + + const result = addsubmuldiv_gpu.uploadMatrixPlusMatrixDownload( + a, b, [2, 2], MatrixOrientation.REGULAR, MatrixOrientation.TRANSPOSED); + + const expected = new Float32Array([4, 2, 4, 6]); + test_util.expectArraysClose(result, expected, 0.0001); + }); + + it('writes the element-wise A^T + B^T to result', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array([3, 1, 0, 2]); + + const result = addsubmuldiv_gpu.uploadMatrixPlusMatrixDownload( + a, b, [2, 2], MatrixOrientation.TRANSPOSED, + MatrixOrientation.TRANSPOSED); + + const expected = new Float32Array([4, 3, 3, 6]); + test_util.expectArraysClose(result, expected, 0.0001); + }); +}); diff --git a/src/math/webgl/argmaxequals_gpu.ts b/src/math/webgl/argmaxequals_gpu.ts new file mode 100644 index 0000000000..3f5b7e72a7 --- /dev/null +++ b/src/math/webgl/argmaxequals_gpu.ts @@ -0,0 +1,62 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as argminmax_gpu from './argminmax_gpu'; +import {GPGPUContext} from './gpgpu_context'; +import {IS_NAN_SHADER_FUNC} from './webgl_util'; + +function getFragmentShaderPrologueSource(): string { + return ` + precision highp float; + uniform sampler2D matrixA; + uniform sampler2D matrixB; + varying vec2 resultUV;`; +} + +function getFragmentShaderMainSource(): string { + return ` + void main() { + float argMaxA = getArgMinMax(matrixA); + float argMaxB = getArgMinMax(matrixB); + float value; + if (isNaN(argMaxA)) { + value = argMaxA; + } else if (isNaN(argMaxB)) { + value = argMaxB; + } else { + value = float(argMaxA == argMaxB); + } + gl_FragColor = vec4(value, 0, 0, 0); + }`; +} + +export function getArgMaxEqualsFragmentShaderSource( + rows: number, columns: number): string { + return [ + getFragmentShaderPrologueSource(), + argminmax_gpu.getFragmentShaderGetArgMinMaxSource('>', rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} + +export function argMaxEquals( + gpgpu: GPGPUContext, maxEqualsProgram: WebGLProgram, a: WebGLTexture, + b: WebGLTexture, numRows: number, numCols: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(maxEqualsProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/argmaxequals_gpu_test.ts b/src/math/webgl/argmaxequals_gpu_test.ts new file mode 100644 index 0000000000..f74fbccd54 --- /dev/null +++ b/src/math/webgl/argmaxequals_gpu_test.ts @@ -0,0 +1,63 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as argmaxequals_gpu from './argmaxequals_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +function uploadArgMaxEqualsDownload( + a: Float32Array, b: Float32Array, rows: number, columns: number): number { + const src = + argmaxequals_gpu.getArgMaxEqualsFragmentShaderSource(rows, columns); + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram(src); + const aTexture = gpgpu.createMatrixTexture(rows, columns); + const bTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + gpgpu.uploadMatrixToTexture(bTexture, rows, columns, b); + argmaxequals_gpu.argMaxEquals( + gpgpu, program, aTexture, bTexture, rows, columns, resultTexture); + const result = new Float32Array(4); + gpgpu.gl.readPixels(0, 0, 1, 1, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, result); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} + +describe('argmaxequals_gpu ArgMin', () => { + it('one value in each array', () => { + const a = new Float32Array([3]); + const b = new Float32Array([3]); + const equals = uploadArgMaxEqualsDownload(a, b, 1, 1); + expect(equals).toEqual(1); + }); + + it('different argmax values', () => { + const a = new Float32Array([2, 3]); + const b = new Float32Array([3, 2]); + const equals = uploadArgMaxEqualsDownload(a, b, 1, 2); + expect(equals).toEqual(0); + }); + + it('same argmax values', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 4, 3, 2, 1]); + const b = new Float32Array([10, 2, 30, 4, 50, 4, 30, 2, 10]); + const equals = uploadArgMaxEqualsDownload(a, b, 1, 9); + expect(equals).toEqual(1); + }); +}); \ No newline at end of file diff --git a/src/math/webgl/argminmax_gpu.ts b/src/math/webgl/argminmax_gpu.ts new file mode 100644 index 0000000000..2d0874cf0b --- /dev/null +++ b/src/math/webgl/argminmax_gpu.ts @@ -0,0 +1,90 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import {IS_NAN_SHADER_FUNC} from './webgl_util'; + +export function getFragmentShaderPrologueSource(): string { + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 resultUV;`; +} + +function getFragmentShaderMainSource(): string { + return ` + void main() { + gl_FragColor = vec4(getArgMinMax(matrixA), 0, 0, 0); + }`; +} + +function getArgMinMaxFragmentShaderSource( + rows: number, columns: number, compOp: string): string { + return [ + getFragmentShaderPrologueSource(), + getFragmentShaderGetArgMinMaxSource(compOp, rows, columns), + getFragmentShaderMainSource() + ].join('\n'); +} + +export function getArgMinFragmentShaderSource( + rows: number, columns: number): string { + return getArgMinMaxFragmentShaderSource(rows, columns, '<'); +} + +export function getArgMaxFragmentShaderSource( + rows: number, columns: number): string { + return getArgMinMaxFragmentShaderSource(rows, columns, '>'); +} + +export function getFragmentShaderGetArgMinMaxSource( + compOp: string, rows: number, columns: number) { + return ` + const vec2 dimCR = vec2(${columns}.0, ${rows}.0); + const vec2 halfCR = vec2(0.5, 0.5); + + ${IS_NAN_SHADER_FUNC} + + float getArgMinMax(in sampler2D matrix) { + vec2 bestCR = vec2(0, 0); + float bestValue = texture2D(matrix, bestCR).r; + + for (float c = 0.0; c < dimCR.x; c += 1.0) { + for (float r = 0.0; r < dimCR.y; r += 1.0) { + vec2 cr = vec2(c, r); + vec2 uv = (cr + halfCR) / dimCR; + float value = texture2D(matrix, uv).r; + if (isNaN(value)) { + return value; + } + if (value ${compOp} bestValue) { + bestValue = value; + bestCR = cr; + } + } + } + return bestCR.x + (bestCR.y * dimCR.x); + } + `; +} + +export function argMinMax( + gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture, + aNumRows: number, aNumCols: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/argminmax_gpu_test.ts b/src/math/webgl/argminmax_gpu_test.ts new file mode 100644 index 0000000000..077efe1f3a --- /dev/null +++ b/src/math/webgl/argminmax_gpu_test.ts @@ -0,0 +1,119 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as argminmax_gpu from './argminmax_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +function uploadArgMinMaxDownloadDriver( + a: Float32Array, rows: number, columns: number, + fragmentShaderSource: string): number { + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram(fragmentShaderSource); + const aTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + argminmax_gpu.argMinMax( + gpgpu, program, aTexture, rows, columns, resultTexture); + const result = new Float32Array(4); + gpgpu.gl.readPixels(0, 0, 1, 1, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, result); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} + +function uploadArgMinDownload( + a: Float32Array, rows: number, columns: number): number { + const src = argminmax_gpu.getArgMinFragmentShaderSource(rows, columns); + return uploadArgMinMaxDownloadDriver(a, rows, columns, src); +} + +function uploadArgMaxDownload( + a: Float32Array, rows: number, columns: number): number { + const src = argminmax_gpu.getArgMaxFragmentShaderSource(rows, columns); + return uploadArgMinMaxDownloadDriver(a, rows, columns, src); +} + +describe('argminmax_gpu ArgMin', () => { + it('returns the only value in a 1x1 input matrix', () => { + const a = new Float32Array([3]); + const argMin = uploadArgMinDownload(a, 1, 1); + expect(argMin).toEqual(0); + }); + + it('returns min indices when not in first cell', () => { + const a = new Float32Array([0, 100, -12, 0]); // row-major + const argMin = uploadArgMinDownload(a, 2, 2); + expect(argMin).toEqual(2); + }); + + it('finds the min value of a large array', () => { + const a = new Float32Array(1024 * 1024); + test_util.setValue(a, 1024, 1024, -100, 17, 913); + const argMin = uploadArgMinDownload(a, 1024, 1024); + expect(argMin).toEqual((17 * 1024) + 913); + }); + + it('returns the correct column and row when matrix is non-square', () => { + const a = new Float32Array(19 * 254); + test_util.setValue(a, 19, 254, -1, 13, 200); + const argMin = uploadArgMinDownload(a, 19, 254); + expect(argMin).toEqual((13 * 254) + 200); + }); + + it('works when the min element is the bottom/right cell in matrix', () => { + const a = new Float32Array(129 * 129); + test_util.setValue(a, 129, 129, -19, 128, 128); + const argMin = uploadArgMinDownload(a, 129, 129); + expect(argMin).toEqual((128 * 129) + 128); + }); +}); + +describe('argminmax_gpu ArgMax', () => { + it('returns the only value in a 1x1 input matrix', () => { + const a = new Float32Array([3]); + const argMax = uploadArgMaxDownload(a, 1, 1); + expect(argMax).toEqual(0); + }); + + it('returns min indices when not in first cell', () => { + const a = new Float32Array([0, -12, 100, 0]); // row-major + const argMax = uploadArgMaxDownload(a, 2, 2); + expect(argMax).toEqual(2); + }); + + it('finds the max value of a large array', () => { + const a = new Float32Array(1024 * 1024); + test_util.setValue(a, 1024, 1024, 100, 17, 913); + const argMax = uploadArgMaxDownload(a, 1024, 1024); + expect(argMax).toEqual((17 * 1024) + 913); + }); + + it('returns the correct column and row when matrix is non-square', () => { + const a = new Float32Array(19 * 254); + test_util.setValue(a, 19, 254, 109, 13, 200); + const argMax = uploadArgMaxDownload(a, 19, 254); + expect(argMax).toEqual((13 * 254) + 200); + }); + + it('works when the min element is the bottom/right cell in matrix', () => { + const a = new Float32Array(129 * 129); + test_util.setValue(a, 129, 129, 19, 128, 128); + const argMax = uploadArgMaxDownload(a, 129, 129); + expect(argMax).toEqual((128 * 129) + 128); + }); +}); diff --git a/src/math/webgl/avg_pool_gpu.ts b/src/math/webgl/avg_pool_gpu.ts new file mode 100644 index 0000000000..eb59aaf4e9 --- /dev/null +++ b/src/math/webgl/avg_pool_gpu.ts @@ -0,0 +1,30 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as pool_gpu from './pool_gpu'; + +export function getFragmentShaderAvgPoolSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number) { + return pool_gpu.getFragmentShaderPoolCommonSource( + xShapeRCD, fSize, stride, pad, 'avg', false); +} + +export function avgPool( + gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture, + result: WebGLTexture, resultShapeRowCol: [number, number]) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} \ No newline at end of file diff --git a/src/math/webgl/avg_pool_gpu_test.ts b/src/math/webgl/avg_pool_gpu_test.ts new file mode 100644 index 0000000000..d74c98a38e --- /dev/null +++ b/src/math/webgl/avg_pool_gpu_test.ts @@ -0,0 +1,112 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import * as avg_pool_gpu from './avg_pool_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('avg_pool_gpu', () => { + function uploadAvgPoolDownload( + a: Float32Array, aShapeRowColDepth: [number, number, number], + fieldSize: number, stride: number, zeroPad: number): Float32Array { + const aTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + aShapeRowColDepth, fieldSize, aShapeRowColDepth[2], stride, + zeroPad); + + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = avg_pool_gpu.getFragmentShaderAvgPoolSource( + aShapeRowColDepth, fieldSize, stride, zeroPad); + const program = gpgpu.createProgram(shaderSource); + + const aTex = gpgpu.createMatrixTexture(aTexShapeRC[0], aTexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(aTex, aTexShapeRC[0], aTexShapeRC[1], a); + + avg_pool_gpu.avgPool(gpgpu, program, aTex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + function compareToCPU( + xShape: [number, number, number], fSize: number, stride: number, + pad: number) { + const x = NDArray.randNormal(xShape); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = mathCPU.avgPool(x, fSize, stride, pad); + const yGPU = + uploadAvgPoolDownload(x.getValues(), x.shape, fSize, stride, pad); + + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const depth = 1; + const dyShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(dyShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=1,f=3,s=2,p=1', () => { + const depth = 1; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=4,f=2,s=1,p=0', () => { + const depth = 4; + const inputShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=3,f=3,s=3,p=1', () => { + const depth = 3; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); +}); \ No newline at end of file diff --git a/src/math/webgl/batchnorm_gpu.ts b/src/math/webgl/batchnorm_gpu.ts new file mode 100644 index 0000000000..6a93267a97 --- /dev/null +++ b/src/math/webgl/batchnorm_gpu.ts @@ -0,0 +1,131 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + xTexShapeRC: [number, number], meanTexShapeRC: [number, number], + varianceTexShapeRC: [number, number], + offsetTexShapeRC: [number, number]|null, + scaleTexShapeRC?: [number, number]|null, varianceEpsilon = 0.001): string { + let offsetSamplerSnippet = ''; + let offsetShapeInitializationSnippet = ''; + let offsetCoordsSnippet = ''; + let offsetUVSnippet = ''; + let offsetValueSnippet = ''; + let offsetOperationSnippet = '0.0'; + + let scaleSamplerSnippet = ''; + let scaleShapeInitializationSnippet = ''; + let scaleCoordsSnippet = ''; + let scaleUVSnippet = ''; + let scaleValueSnippet = ''; + let scaleOperationSnippet = ''; + + if (offsetTexShapeRC != null) { + offsetSamplerSnippet = 'uniform sampler2D offset;'; + offsetShapeInitializationSnippet = `const vec2 offsetShapeCR = vec2( + ${offsetTexShapeRC[1]}, ${offsetTexShapeRC[0]});`; + offsetCoordsSnippet = 'vec2 offsetCoordsCR = mod(yTexCR, offsetShapeCR);'; + offsetUVSnippet = + 'vec2 offsetUV = (offsetCoordsCR + halfCR) / offsetShapeCR;'; + offsetValueSnippet = 'float offsetValue = texture2D(offset, offsetUV).r;'; + offsetOperationSnippet = 'offsetValue'; + } + + if (scaleTexShapeRC != null) { + scaleSamplerSnippet = 'uniform sampler2D scale;'; + scaleShapeInitializationSnippet = `const vec2 scaleShapeCR = vec2( + ${scaleTexShapeRC[1]}, ${scaleTexShapeRC[0]});`; + scaleCoordsSnippet = 'vec2 scaleCoordsCR = mod(yTexCR, scaleShapeCR);'; + scaleUVSnippet = 'vec2 scaleUV = (scaleCoordsCR + halfCR) / scaleShapeCR;'; + scaleValueSnippet = 'float scaleValue = texture2D(scale, scaleUV).r;'; + scaleOperationSnippet = 'inv *= scaleValue;'; + } + + return ` + precision highp float; + uniform sampler2D x; + uniform sampler2D mean; + uniform sampler2D variance; + ${offsetSamplerSnippet} + ${scaleSamplerSnippet} + + varying vec2 resultUV; + + const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]}); + const vec2 meanShapeCR = vec2(${meanTexShapeRC[1]}, ${meanTexShapeRC[0]}); + const vec2 varianceShapeCR = vec2( + ${varianceTexShapeRC[1]}, ${varianceTexShapeRC[0]}); + + ${offsetShapeInitializationSnippet} + ${scaleShapeInitializationSnippet} + + const vec2 halfCR = vec2(0.5, 0.5); + const float varianceEpsilon = ${varianceEpsilon}; + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + vec2 meanCoordsCR = mod(yTexCR, meanShapeCR); + vec2 varianceCoordsCR = mod(yTexCR, varianceShapeCR); + ${offsetCoordsSnippet} + ${scaleCoordsSnippet} + + vec2 meanUV = (meanCoordsCR + halfCR) / meanShapeCR; + vec2 varianceUV = (varianceCoordsCR + halfCR) / varianceShapeCR; + ${offsetUVSnippet} + ${scaleUVSnippet} + + float xValue = texture2D(x, resultUV).r; + float meanValue = texture2D(mean, meanUV).r; + float varianceValue = texture2D(variance, varianceUV).r; + ${offsetValueSnippet} + ${scaleValueSnippet} + + float inv = 1.0 / sqrt(varianceValue + varianceEpsilon); + ${scaleOperationSnippet} + float xTimesInv = xValue * inv; + float meanTimesInvWithOffset = ${offsetOperationSnippet} + - meanValue * inv; + + gl_FragColor = vec4(xTimesInv + meanTimesInvWithOffset, 0, 0, 0); + }`; +} + +export function batchNormalization( + gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture, + xShapeRowCol: [number, number], mean: WebGLTexture, + meanShapeRowCol: [number, number], variance: WebGLTexture, + varianceShapeRowCol: [number, number], offset: WebGLTexture|null, + offsetShapeRowCol: [number, number]|null, scale: WebGLTexture|null, + scaleShapeRowCol: [number, number]|null, result: WebGLTexture, + resultShapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.setInputMatrixTexture(mean, 'mean', 1); + gpgpu.setInputMatrixTexture(variance, 'variance', 2); + let nextIndex = 3; + if (offset != null) { + gpgpu.setInputMatrixTexture(offset, 'offset', nextIndex); + nextIndex++; + } + if (scale != null) { + gpgpu.setInputMatrixTexture(scale, 'scale', nextIndex); + } + gpgpu.executeProgram(); +} \ No newline at end of file diff --git a/src/math/webgl/batchnorm_gpu_test.ts b/src/math/webgl/batchnorm_gpu_test.ts new file mode 100644 index 0000000000..6dcbaead0c --- /dev/null +++ b/src/math/webgl/batchnorm_gpu_test.ts @@ -0,0 +1,217 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import * as batchnorm_gpu from './batchnorm_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('batchnorm gpu test', () => { + function uploadBatchNormDownload( + x: Float32Array, xTexShapeRowCol: [number, number], mean: Float32Array, + meanTexShapeRowCol: [number, number], variance: Float32Array, + varianceTexShapeRowCol: [number, number], offset: Float32Array|null, + offsetTexShapeRowCol: [number, number]|null, scale: Float32Array|null, + scaleTexShapeRowCol: [number, number]|null, + varianceEpsilon: number): Float32Array { + const resultTexShapeRC: [number, number] = xTexShapeRowCol; + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = batchnorm_gpu.getFragmentShaderSource( + xTexShapeRowCol, meanTexShapeRowCol, varianceTexShapeRowCol, + offsetTexShapeRowCol, scaleTexShapeRowCol, varianceEpsilon); + + const program = gpgpu.createProgram(shaderSource); + + const xTex = + gpgpu.createMatrixTexture(xTexShapeRowCol[0], xTexShapeRowCol[1]); + const meanTex = + gpgpu.createMatrixTexture(meanTexShapeRowCol[0], meanTexShapeRowCol[1]); + const varianceTex = gpgpu.createMatrixTexture( + varianceTexShapeRowCol[0], varianceTexShapeRowCol[1]); + + let offsetTex = null; + if (offset != null) { + offsetTex = gpgpu.createMatrixTexture( + offsetTexShapeRowCol![0], offsetTexShapeRowCol![1]); + } + let scaleTex = null; + if (scale != null) { + scaleTex = gpgpu.createMatrixTexture( + scaleTexShapeRowCol![0], scaleTexShapeRowCol![1]); + } + + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture( + xTex, xTexShapeRowCol[0], xTexShapeRowCol[1], x); + gpgpu.uploadMatrixToTexture( + meanTex, meanTexShapeRowCol[0], meanTexShapeRowCol[1], mean); + gpgpu.uploadMatrixToTexture( + varianceTex, varianceTexShapeRowCol[0], varianceTexShapeRowCol[1], + variance); + if (offset != null) { + gpgpu.uploadMatrixToTexture( + offsetTex!, offsetTexShapeRowCol![0], offsetTexShapeRowCol![1], + offset); + } + if (scale != null) { + gpgpu.uploadMatrixToTexture( + scaleTex!, scaleTexShapeRowCol![0], scaleTexShapeRowCol![1], scale); + } + + batchnorm_gpu.batchNormalization( + gpgpu, program, xTex, xTexShapeRowCol, meanTex, meanTexShapeRowCol, + varianceTex, varianceTexShapeRowCol, offsetTex, offsetTexShapeRowCol, + scaleTex, scaleTexShapeRowCol, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteMatrixTexture(meanTex); + gpgpu.deleteMatrixTexture(varianceTex); + if (offsetTex != null) { + gpgpu.deleteMatrixTexture(offsetTex); + } + if (scaleTex != null) { + gpgpu.deleteMatrixTexture(scaleTex); + } + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + it('simple batchnorm, no offset or scale, 2x1x2', () => { + const x = new Float32Array([2, 100, 4, 400]); + const mean = new Float32Array([1, 2]); + const variance = new Float32Array([2, 3]); + const varianceEpsilon = .001; + + const result = uploadBatchNormDownload( + x, [2, 2], mean, [1, 2], variance, [1, 2], null, null, null, null, + varianceEpsilon); + + const expectedResult = new Float32Array([ + (x[0] - mean[0]) * 1 / Math.sqrt(variance[0] + varianceEpsilon), + (x[1] - mean[1]) * 1 / Math.sqrt(variance[1] + varianceEpsilon), + (x[2] - mean[0]) * 1 / Math.sqrt(variance[0] + varianceEpsilon), + (x[3] - mean[1]) * 1 / Math.sqrt(variance[1] + varianceEpsilon) + ]); + test_util.expectArraysClose(result, expectedResult, 1e-5); + }); + + it('simple batchnorm, no offset, 2x1x2', () => { + const x = new Float32Array([2, 100, 4, 400]); + const mean = new Float32Array([1, 2]); + const variance = new Float32Array([2, 3]); + const scale = new Float32Array([4, 5]); + const varianceEpsilon = .001; + + const result = uploadBatchNormDownload( + x, [2, 2], mean, [1, 2], variance, [1, 2], null, null, scale, [1, 2], + varianceEpsilon); + + const expectedResult = new Float32Array([ + (x[0] - mean[0]) * scale[0] / Math.sqrt(variance[0] + varianceEpsilon), + (x[1] - mean[1]) * scale[1] / Math.sqrt(variance[1] + varianceEpsilon), + (x[2] - mean[0]) * scale[0] / Math.sqrt(variance[0] + varianceEpsilon), + (x[3] - mean[1]) * scale[1] / Math.sqrt(variance[1] + varianceEpsilon) + ]); + test_util.expectArraysClose(result, expectedResult, 1e-5); + }); + + it('simple batchnorm, no scale, 2x1x2', () => { + const x = new Float32Array([2, 100, 4, 400]); + const mean = new Float32Array([1, 2]); + const variance = new Float32Array([2, 3]); + const offset = new Float32Array([4, 5]); + const varianceEpsilon = .001; + + const result = uploadBatchNormDownload( + x, [2, 2], mean, [1, 2], variance, [1, 2], offset, [1, 2], null, null, + varianceEpsilon); + + const expectedResult = new Float32Array([ + offset[0] + + (x[0] - mean[0]) * 1 / Math.sqrt(variance[0] + varianceEpsilon), + offset[1] + + (x[1] - mean[1]) * 1 / Math.sqrt(variance[1] + varianceEpsilon), + offset[0] + + (x[2] - mean[0]) * 1 / Math.sqrt(variance[0] + varianceEpsilon), + offset[1] + + (x[3] - mean[1]) * 1 / Math.sqrt(variance[1] + varianceEpsilon) + ]); + test_util.expectArraysClose(result, expectedResult, 1e-5); + }); + + it('simple batchnorm, 2x1x2', () => { + const x = new Float32Array([2, 100, 4, 400]); + const mean = new Float32Array([1, 2]); + const variance = new Float32Array([2, 3]); + const offset = new Float32Array([3, 4]); + const scale = new Float32Array([4, 5]); + const varianceEpsilon = .001; + + const result = uploadBatchNormDownload( + x, [2, 2], mean, [1, 2], variance, [1, 2], offset, [1, 2], scale, + [1, 2], varianceEpsilon); + + const expectedResult = new Float32Array([ + offset[0] + + (x[0] - mean[0]) * scale[0] / + Math.sqrt(variance[0] + varianceEpsilon), + offset[1] + + (x[1] - mean[1]) * scale[1] / + Math.sqrt(variance[1] + varianceEpsilon), + offset[0] + + (x[2] - mean[0]) * scale[0] / + Math.sqrt(variance[0] + varianceEpsilon), + offset[1] + + (x[3] - mean[1]) * scale[1] / Math.sqrt(variance[1] + varianceEpsilon) + ]); + test_util.expectArraysClose(result, expectedResult, 1e-5); + }); + + it('batchnorm matches tensorflow, 2x3x3', () => { + const x = new Float32Array([ + 0.49955603, 0.04158615, -1.09440524, 2.03854165, -0.61578344, 2.87533573, + 1.18105987, 0.807462, 1.87888837, 2.26563962, -0.37040935, 1.35848753, + -0.75347094, 0.15683117, 0.91925946, 0.34121279, 0.92717143, 1.89683965 + ]); + const mean = new Float32Array([0.39745062, -0.48062894, 0.4847822]); + const variance = new Float32Array([0.32375343, 0.67117643, 1.08334653]); + const offset = new Float32Array([0.69398749, -1.29056387, 0.9429723]); + const scale = new Float32Array([-0.5607271, 0.9878457, 0.25181573]); + const varianceEpsilon = .001; + + const result = uploadBatchNormDownload( + x, [2, 9], mean, [1, 3], variance, [1, 3], offset, [1, 3], scale, + [1, 3], varianceEpsilon); + + const expectedResult = new Float32Array([ + 0.59352049, -0.66135202, 0.5610874, -0.92077015, -1.45341019, 1.52106473, + -0.07704776, 0.26144429, 1.28010017, -1.14422404, -1.15776136, 1.15425493, + 1.82644104, -0.52249442, 1.04803919, 0.74932291, 0.40568101, 1.2844412 + ]); + test_util.expectArraysClose(result, expectedResult, 1e-5); + }); +}); \ No newline at end of file diff --git a/src/math/webgl/binaryop_gpu.ts b/src/math/webgl/binaryop_gpu.ts new file mode 100644 index 0000000000..4a793d9342 --- /dev/null +++ b/src/math/webgl/binaryop_gpu.ts @@ -0,0 +1,78 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + aResultUV: string, bResultUV: string, op: string): string { + return ` + precision highp float; + uniform sampler2D matrixA; + uniform sampler2D matrixB; + varying vec2 resultUV; + + void main() { + float a = texture2D(matrixA, ${aResultUV}).r; + float b = texture2D(matrixB, ${bResultUV}).r; + ${op} + }`; +} + +export function binaryOp( + gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, + aShapeRowCol: [number, number], b: WebGLTexture, + bShapeRowCol: [number, number], result: WebGLTexture, + resultShapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} + +export function uploadBinaryOpDownload( + a: Float32Array, aShape: [number, number], b: Float32Array, + bShape: [number, number], fragmentShaderSource: string): Float32Array { + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram(fragmentShaderSource); + + const aTexture: WebGLTexture = + gpgpu.createMatrixTexture(aShape[0], aShape[1]); + const bTexture: WebGLTexture = + gpgpu.createMatrixTexture(bShape[0], bShape[1]); + + const resultShape: [number, number] = + [Math.max(aShape[0], bShape[0]), Math.max(aShape[1], bShape[1])]; + + const resultTexture: WebGLTexture = + gpgpu.createMatrixTexture(resultShape[0], resultShape[1]); + + gpgpu.uploadMatrixToTexture(aTexture, aShape[0], aShape[1], a); + gpgpu.uploadMatrixToTexture(bTexture, bShape[0], bShape[1], b); + + binaryOp( + gpgpu, program, aTexture, aShape, bTexture, bShape, resultTexture, + resultShape); + const result = gpgpu.downloadMatrixFromTexture( + resultTexture, resultShape[0], resultShape[1]); + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} diff --git a/src/math/webgl/concat3d_gpu.ts b/src/math/webgl/concat3d_gpu.ts new file mode 100644 index 0000000000..ebe37d7ab3 --- /dev/null +++ b/src/math/webgl/concat3d_gpu.ts @@ -0,0 +1,74 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + x1ShapeRCD: [number, number, number], x2ShapeRCD: [number, number, number], + resultShapeRCD: [number, number, number], axis: number): string { + const x1TexShapeRC = conv_util.computeTexShapeFrom3D(x1ShapeRCD); + const x2TexShapeRC = conv_util.computeTexShapeFrom3D(x2ShapeRCD); + + const yAxes = ['yR', 'yC', 'yD']; + const concatAxis = yAxes[axis]; + + return ` + precision highp float; + uniform sampler2D x1; + uniform sampler2D x2; + + const vec2 x1ShapeCR = vec2(${x1TexShapeRC[1]}, ${x1TexShapeRC[0]}); + const vec2 x2ShapeCR = vec2(${x2TexShapeRC[1]}.0, ${x2TexShapeRC[0]}.0); + + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (yTexR, yTexC) to 3D (yR, yC, yD). + float yR = yTexCR.y; + float yC = floor(yTexCR.x / ${resultShapeRCD[2]}.0); + float yD = mod(yTexCR.x, ${resultShapeRCD[2]}.0); + + float value = 0.0; + + if (${concatAxis} < ${x1ShapeRCD[axis]}.0) { + // Map yR, yC, yD back to x1 coordinates. + vec2 x1CR = vec2(yC * ${x1ShapeRCD[2]}.0 + yD, yR); + vec2 x1UV = (x1CR + halfCR) / x1ShapeCR; + value = texture2D(x1, x1UV).r; + } else { + ${concatAxis} = ${concatAxis} - ${x1ShapeRCD[axis]}.0; + + // Map yR, yC, yD back to x2 coordinates. + vec2 x2CR = vec2(yC * ${x2ShapeRCD[2]}.0 + yD, yR); + vec2 x2UV = (x2CR + halfCR) / x2ShapeCR; + value = texture2D(x2, x2UV).r; + } + + gl_FragColor = vec4(value, 0.0, 0.0, 0.0); + }`; +} + +export function concat3D( + gpgpu: GPGPUContext, program: WebGLProgram, x1: WebGLTexture, + x2: WebGLTexture, result: WebGLTexture, resultShapeRC: [number, number]) { + gpgpu.setOutputMatrixTexture(result, resultShapeRC[0], resultShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x1, 'x1', 0); + gpgpu.setInputMatrixTexture(x2, 'x2', 1); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/concat3d_gpu_test.ts b/src/math/webgl/concat3d_gpu_test.ts new file mode 100644 index 0000000000..00ee4b14d0 --- /dev/null +++ b/src/math/webgl/concat3d_gpu_test.ts @@ -0,0 +1,105 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; + +import * as concat3d_gpu from './concat3d_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('concat3d_gpu', () => { + + function uploadConcat3dDownload( + x1: Float32Array, x2: Float32Array, x1ShapeRCD: [number, number, number], + x2ShapeRCD: [number, number, number], axis: number): Float32Array { + const x1TexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(x1ShapeRCD); + const x2TexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(x2ShapeRCD); + + const resultShapeRCD = x1ShapeRCD.slice() as [number, number, number]; + resultShapeRCD[axis] += x2ShapeRCD[axis]; + const resultTexShapeRC = conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = concat3d_gpu.getFragmentShaderSource( + x1ShapeRCD, x2ShapeRCD, resultShapeRCD, axis); + const program = gpgpu.createProgram(shaderSource); + + const x1Tex = gpgpu.createMatrixTexture(x1TexShapeRC[0], x1TexShapeRC[1]); + const x2Tex = gpgpu.createMatrixTexture(x2TexShapeRC[0], x2TexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(x1Tex, x1TexShapeRC[0], x1TexShapeRC[1], x1); + gpgpu.uploadMatrixToTexture(x2Tex, x2TexShapeRC[0], x2TexShapeRC[1], x2); + + concat3d_gpu.concat3D( + gpgpu, program, x1Tex, x2Tex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(x1Tex); + gpgpu.deleteMatrixTexture(x2Tex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + it('concat axis=0', () => { + const x1 = new Float32Array([1, 11, 111, 2, 22, 222]); + const x2 = + new Float32Array([5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + + const result = uploadConcat3dDownload(x1, x2, [1, 2, 3], [2, 2, 3], 0); + test_util.expectArraysClose( + result, new Float32Array([ + 1, 11, 111, 2, 22, 222, 5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888 + ]), + 1e-6); + + }); + + it('concat axis=1', () => { + const x1 = new Float32Array([1, 11, 111, 3, 33, 333]); + const x2 = + new Float32Array([5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + + const result = uploadConcat3dDownload(x1, x2, [2, 1, 3], [2, 2, 3], 1); + test_util.expectArraysClose( + result, new Float32Array([ + 1, 11, 111, 5, 55, 555, 6, 66, 666, 3, 33, 333, 7, 77, 777, 8, 88, 888 + ]), + 1e-6); + }); + + it('concat axis=2', () => { + const x1 = new Float32Array([1, 11, 2, 22, 3, 33, 4, 44]); + const x2 = + new Float32Array([5, 55, 555, 6, 66, 666, 7, 77, 777, 8, 88, 888]); + + const result = uploadConcat3dDownload(x1, x2, [2, 2, 2], [2, 2, 3], 2); + test_util.expectArraysClose( + result, new Float32Array([ + 1, 11, 5, 55, 555, 2, 22, 6, 66, 666, + 3, 33, 7, 77, 777, 4, 44, 8, 88, 888 + ]), + 1e-6); + }); +}); diff --git a/src/math/webgl/conv_backprop_gpu.ts b/src/math/webgl/conv_backprop_gpu.ts new file mode 100644 index 0000000000..15aca3485e --- /dev/null +++ b/src/math/webgl/conv_backprop_gpu.ts @@ -0,0 +1,252 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; + +import * as conv_gpu from './conv_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderDerWeightsSource( + xShapeRowColDepth: [number, number, number], fSize: number, + outputDepth: number, stride: number, zeroPad: number) { + const getMatrixValueOrZeroPad = + conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + const inputDepth = xShapeRowColDepth[2]; + + const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + + const yShape = conv_util.computeOutputShape3D( + xShapeRowColDepth, fSize, outputDepth, stride, zeroPad); + const yNumRows = yShape[0]; + const yNumCols = yShape[1]; + const yTexShapeRC = conv_util.computeTexShapeFrom3D(yShape); + + const fSizeTimesInputDepth = fSize * inputDepth; + + const prologue = ` + precision highp float; + uniform sampler2D x; + uniform sampler2D dy; + `; + + return prologue + '\n' + getMatrixValueOrZeroPad + '\n' + + ` + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]}); + const vec2 dyShapeCR = vec2(${yTexShapeRC[1]}, ${yTexShapeRC[0]}); + + void main() { + vec2 wTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (wTexR, wTexC) to 4D (wR, wC, d1, d2). + float wR = floor(wTexCR.y / ${fSizeTimesInputDepth}.0); + float wTexRLeftover = wTexCR.y - wR * ${fSizeTimesInputDepth}.0; + float wC = floor(wTexRLeftover / ${inputDepth}.0); + float d1 = mod(wTexRLeftover, ${inputDepth}.0); + float d2 = wTexCR.x; + + // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2). + // ? = to be determined. : = across all values in that axis. + float dotProd = 0.0; + for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) { + float xR = wR + yR * ${stride}.0 - ${zeroPad}.0; + float xTexR = xR; + float yTexR = yR; + for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) { + float xC = wC + yC * ${stride}.0 - ${zeroPad}.0; + + // Map from 3D (xR, xC, d1) to 2D (xTexR, xTexC). + // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC). + vec2 xyTexC = vec2(xC, yC) * vec2(${inputDepth}.0, ${outputDepth}.0) + + vec2(d1, d2); + float xTexC = xyTexC.x; + float yTexC = xyTexC.y; + + // Read dy(yR, yC, d2). + vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR; + float dyValue = texture2D(dy, dyUV).r; + + // Read x(xR, xC, d1) (potentially zero-padded). + float xValue = + getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR)); + + dotProd += (xValue * dyValue); + } + } + gl_FragColor = vec4(dotProd, 0, 0, 0); + }`; +} + +export function getFragmentShaderConvTransposeSource( + xShapeRCD: [number, number, number], fSize: number, origInputDepth: number, + origStride: number, origPad: number, hasBias: boolean) { + const pad = fSize - 1 - origPad; + const [xRows, xCols, origOutputDepth] = xShapeRCD; + + const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + const wTexShapeRC = + conv_util.computeWeightsTexShape(origInputDepth, origOutputDepth, fSize); + + const getBiasValue = hasBias ? + conv_gpu.getFragmentShaderGetBiasValueSource(origInputDepth) : + ''; + const biasPrologue = hasBias ? 'uniform sampler2D biases;' : ''; + const biasOperation = hasBias ? 'dotProd += getBiasValue(biases, d2);' : ''; + + const prologue = ` + precision highp float; + uniform sampler2D x; + uniform sampler2D weights; + ${biasPrologue} + `; + + return prologue + '\n' + getBiasValue + '\n' + + ` + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]}); + const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]}); + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2). + float yR = yTexCR.y; + float yC = floor(yTexCR.x / ${origInputDepth}.0); + float d2 = mod(yTexCR.x, ${origInputDepth}.0); + + vec2 xRCCorner = vec2(yR, yC) - vec2(${pad}.0, ${pad}.0); + float xRCorner = xRCCorner.x; + float xCCorner = xRCCorner.y; + + // Convolve x(?, ?, d1) with w(:, :, d2, d1) to get y(yR, yC, d2). + // ? = to be determined. : = across all values in that axis. + float dotProd = 0.0; + for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) { + + float xR = (xRCorner + wR) / ${origStride}.0; + // TODO(smilkov): Splice this with another version where you call + // getMatrixValueOrZeroPad(). Here and below. + if (xR < 0.0 || xR >= ${xRows}.0 || fract(xR) > 0.0) { + continue; + } + + float wRPerm = ${fSize}.0 - 1.0 - wR; + float xTexR = xR; + + for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) { + + float xC = (xCCorner + wC) / ${origStride}.0; + if (xC < 0.0 || xC >= ${xCols}.0 || fract(xC) > 0.0) { + continue; + } + + float wCPerm = ${fSize}.0 - 1.0 - wC; + float wTexR = wRPerm * ${fSize}.0 * ${origInputDepth}.0 + + wCPerm * ${origInputDepth}.0 + d2; + + for (float d1 = 0.0; d1 < ${origOutputDepth}.0; d1 += 1.0) { + float xTexC = xC * ${origOutputDepth}.0 + d1; + float wTexC = d1; + + // Read x(xR, xC, d1). + vec2 xUV = (vec2(xTexC, xTexR) + halfCR) / xShapeCR; + float xValue = texture2D(x, xUV).r; + + // Read w(wRPerm, wCPerm, d2, d1). + vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR; + float wValue = texture2D(weights, wUV).r; + + dotProd += xValue * wValue; + } + } + } + ${biasOperation} + gl_FragColor = vec4(dotProd, 0, 0, 0); + }`; +} + +export function getFragmentShaderDerBiasSource( + dyShapeRCD: [number, number, number]) { + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + const [yNumRows, yNumCols, outputDepth] = dyShapeRCD; + + return ` + precision highp float; + uniform sampler2D dy; + + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]}); + + void main() { + vec2 biasTexCR = floor(gl_FragCoord.xy); + + // The bias texture RC shape is [1, d2]. + float d2 = biasTexCR.x; + + float derBias = 0.0; + for (float yR = 0.0; yR < ${yNumRows}.0; yR += 1.0) { + float yTexR = yR; + + for (float yC = 0.0; yC < ${yNumCols}.0; yC += 1.0) { + // Map from 3D (yR, yC, d2) to 2D (yTexR, yTexC). + float yTexC = yC * ${outputDepth}.0 + d2; + + // Read dy(yR, yC, d2). + vec2 dyUV = (vec2(yTexC, yTexR) + halfCR) / dyShapeCR; + float dyValue = texture2D(dy, dyUV).r; + + derBias += dyValue; + } + } + gl_FragColor = vec4(derBias, 0, 0, 0); + }`; +} + +export function derBias( + gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture, + result: WebGLTexture, resultTexShapeRC: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.executeProgram(); +} + +export function derWeights( + gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture, + dyTex: WebGLTexture, result: WebGLTexture, + resultTexShapeRC: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 1); + gpgpu.executeProgram(); +} + +export function convTranspose( + gpgpu: GPGPUContext, program: WebGLProgram, xTex: WebGLTexture, + weightsTex: WebGLTexture, biasesTex: WebGLTexture|null, + resultTex: WebGLTexture, resultTexShapeRC: [number, number]) { + gpgpu.setOutputMatrixTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(xTex, 'x', 0); + gpgpu.setInputMatrixTexture(weightsTex, 'weights', 1); + if (biasesTex != null) { + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + } + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/conv_backprop_gpu_derbias_test.ts b/src/math/webgl/conv_backprop_gpu_derbias_test.ts new file mode 100644 index 0000000000..efd9c0cb92 --- /dev/null +++ b/src/math/webgl/conv_backprop_gpu_derbias_test.ts @@ -0,0 +1,74 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import * as conv_backprop_gpu from './conv_backprop_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu derBias', () => { + + function uploadDerBiasDownload(dy: Array3D): Float32Array { + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + const src = conv_backprop_gpu.getFragmentShaderDerBiasSource(dy.shape); + const program = gpgpu.createProgram(src); + + // Upload dy. + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dy.shape); + const dyTex = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + dyTex, dyTexShapeRC[0], dyTexShapeRC[1], dy.getValues()); + + const outputDepth = dy.shape[2]; + const resultTexRC = conv_util.computeBiasesTexShape(outputDepth); + const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]); + conv_backprop_gpu.derBias(gpgpu, program, dyTex, resultTex, resultTexRC); + const db = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexRC[0], resultTexRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(dyTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return db; + } + + function compareToCPU(dyShapeRCD: [number, number, number]) { + const dy = NDArray.randNormal(dyShapeRCD); + + const mathCPU = new NDArrayMathCPU(); + const dBiasCPU = mathCPU.conv2dDerBias(dy); + + const dBiasGPU = uploadDerBiasDownload(dy); + test_util.expectArraysClose(dBiasGPU, dBiasCPU.getValues(), 1e-5); + } + + it('matches CPU on random input. dy shape [3, 3, 2]', () => { + compareToCPU([3, 3, 2]); + }); + + it('matches CPU on random input. dy shape [5, 5, 1]', () => { + compareToCPU([5, 5, 1]); + }); + + it('matches CPU on random input. dy shape [1, 1, 8]', () => { + compareToCPU([1, 1, 8]); + }); +}); diff --git a/src/math/webgl/conv_backprop_gpu_derweights_test.ts b/src/math/webgl/conv_backprop_gpu_derweights_test.ts new file mode 100644 index 0000000000..03129d77ac --- /dev/null +++ b/src/math/webgl/conv_backprop_gpu_derweights_test.ts @@ -0,0 +1,120 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import * as conv_backprop_gpu from './conv_backprop_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu derWeights', () => { + + function uploadDerWeightsDownload( + x: Array3D, dy: Array3D, fSize: number, stride: number, + zeroPad: number): Float32Array { + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + const outputDepth = dy.shape[2]; + const src = conv_backprop_gpu.getFragmentShaderDerWeightsSource( + x.shape, fSize, outputDepth, stride, zeroPad); + const program = gpgpu.createProgram(src); + const inputDepth = x.shape[2]; + + // Upload x. + const xTexShapeRC = conv_util.computeTexShapeFrom3D(x.shape); + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + xTex, xTexShapeRC[0], xTexShapeRC[1], x.getValues()); + + // Upload dy. + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dy.shape); + const dyTex = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + dyTex, dyTexShapeRC[0], dyTexShapeRC[1], dy.getValues()); + + const resultTexRC = + conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]); + conv_backprop_gpu.derWeights( + gpgpu, program, xTex, dyTex, resultTex, resultTexRC); + const dw = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexRC[0], resultTexRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteMatrixTexture(dyTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return dw; + } + + function compareToCPU( + inputShape: [number, number, number], fSize: number, outputDepth: number, + stride: number, zeroPad: number) { + const x = NDArray.randNormal(inputShape); + const outputShape = conv_util.computeOutputShape3D( + x.shape, fSize, outputDepth, stride, zeroPad); + const dy = NDArray.randNormal(outputShape); + + const mathCPU = new NDArrayMathCPU(); + const dwCPU = mathCPU.conv2dDerWeights(x, dy, fSize, stride, zeroPad); + + const dwGPU = uploadDerWeightsDownload(x, dy, fSize, stride, zeroPad); + test_util.expectArraysClose(dwGPU, dwCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=3,d2=4,f=2,s=1,p=0', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 2; + const outputDepth = 4; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=3,d2=4,f=3,s=1,p=1', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 3; + const outputDepth = 4; + const stride = 1; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=3,d2=4,f=3,s=2,p=1', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 4; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=3,d2=4,f=3,s=3,p=1', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 4; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); +}); diff --git a/src/math/webgl/conv_backprop_transpose_gpu_test.ts b/src/math/webgl/conv_backprop_transpose_gpu_test.ts new file mode 100644 index 0000000000..9cf4ba3c9a --- /dev/null +++ b/src/math/webgl/conv_backprop_transpose_gpu_test.ts @@ -0,0 +1,144 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array1D, Array3D, Array4D, NDArray} from '../ndarray'; + +import * as conv_backprop_gpu from './conv_backprop_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu transpose', () => { + + function uploadConvTransposeDownload( + x: Array3D, weights: Array4D, biases: Array1D|null, fSize: number, + origStride: number, origPad: number): Float32Array { + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + const origInputDepth = weights.shape[2]; + const origOutputDepth = weights.shape[3]; + const src = conv_backprop_gpu.getFragmentShaderConvTransposeSource( + x.shape, fSize, origInputDepth, origStride, origPad, biases != null); + const program = gpgpu.createProgram(src); + + // Upload x. + const xTexShapeRC = conv_util.computeTexShapeFrom3D(x.shape); + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + xTex, xTexShapeRC[0], xTexShapeRC[1], x.getValues()); + + // Upload weights. + const wTexShapeRC = conv_util.computeWeightsTexShape( + origInputDepth, origOutputDepth, fSize); + const wTex = gpgpu.createMatrixTexture(wTexShapeRC[0], wTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + wTex, wTexShapeRC[0], wTexShapeRC[1], weights.getValues()); + + const biasTexShapeRC = conv_util.computeBiasesTexShape(origInputDepth); + const biasTex = biases != null ? + gpgpu.createMatrixTexture(biasTexShapeRC[0], biasTexShapeRC[1]) : + null; + if (biasTex != null) { + gpgpu.uploadMatrixToTexture( + biasTex, biasTexShapeRC[0], biasTexShapeRC[1], biases!.getValues()); + } + + // Figure out the output shape by dilating the input. + const xRowsDilated = (x.shape[0] - 1) * origStride + 1; + const xColsDilated = (x.shape[1] - 1) * origStride + 1; + const pad = fSize - 1 - origPad; + const resultShapeRCD = conv_util.computeOutputShape3D( + [xRowsDilated, xColsDilated, origOutputDepth], fSize, origInputDepth, 1, + pad); + const resultTexRC = conv_util.computeTexShapeFrom3D(resultShapeRCD); + const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]); + conv_backprop_gpu.convTranspose( + gpgpu, program, xTex, wTex, biasTex, resultTex, resultTexRC); + const y = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexRC[0], resultTexRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteMatrixTexture(wTex); + if (biasTex != null) { + gpgpu.deleteMatrixTexture(biasTex); + } + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return y; + } + + function compareToCPU( + origInputShape: [number, number, number], fSize: number, + origOutputDepth: number, origStride: number, origPad: number) { + const [xNumRows, xNumCols, origInputDepth] = origInputShape; + + const x = + NDArray.randNormal([xNumRows, xNumCols, origOutputDepth]); + + const weights = NDArray.randNormal( + [fSize, fSize, origInputDepth, origOutputDepth]); + const biases = NDArray.randNormal([origInputDepth]); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = + mathCPU.conv2dTranspose(x, weights, biases, origStride, origPad); + const yGPU = uploadConvTransposeDownload( + x, weights, biases, fSize, origStride, origPad); + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 2; + const outputDepth = 1; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=1,d2=1,f=3,s=2,p=1', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 1; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=4,d2=3,f=2,s=1,p=0', () => { + const inputDepth = 4; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 2; + const outputDepth = 3; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=3,d2=4,f=3,s=3,p=1', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 4; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); +}); diff --git a/src/math/webgl/conv_gpu.ts b/src/math/webgl/conv_gpu.ts new file mode 100644 index 0000000000..21f9685041 --- /dev/null +++ b/src/math/webgl/conv_gpu.ts @@ -0,0 +1,151 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderPrologueSource(): string { + return ` + precision highp float; + uniform sampler2D x; + uniform sampler2D weights; + uniform sampler2D biases; + varying vec2 resultUV;`; +} + +export function getFragmentShaderGetMatrixValueOrZeroPadSource(): string { + return ` + float getMatrixValueOrZeroPad(in sampler2D matrix, vec2 matrixShapeCR, + vec2 requestedCR) { + vec2 uv = (requestedCR + vec2(0.5, 0.5)) / matrixShapeCR; + float value = texture2D(matrix, uv).r; + bool lessThanZero = any(lessThan(uv, vec2(0, 0))); + bool greaterThanOne = any(greaterThan(uv, vec2(1, 1))); + bool outside = lessThanZero || greaterThanOne; + return mix(value, 0.0, float(outside)); + }`; +} + +export function getFragmentShaderConvolveSource( + xShapeRCD: [number, number, number], fSize: number, outputDepth: number, + stride: number, pad: number, hasBias: boolean) { + const [xRows, xCols, inputDepth] = xShapeRCD; + + const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + const wTexShapeRC = + conv_util.computeWeightsTexShape(inputDepth, outputDepth, fSize); + + return ` + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]}); + const vec2 wShapeCR = vec2(${wTexShapeRC[1]}, ${wTexShapeRC[0]}); + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2). + float yR = yTexCR.y; + float yC = floor(yTexCR.x / ${outputDepth}.0); + float d2 = mod(yTexCR.x, ${outputDepth}.0); + float wTexC = d2; + + vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) - + vec2(${pad}.0, ${pad}.0); + float xRCorner = xRCCorner.x; + float xCCorner = xRCCorner.y; + + // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2). + // ? = to be determined. : = across all values in that axis. + float dotProd = 0.0; + for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) { + float xR = xRCorner + wR; + float xTexR = xR; + + for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) { + float xC = xCCorner + wC; + + for (float d1 = 0.0; d1 < ${inputDepth}.0; d1 += 1.0) { + float xTexC = xC * ${inputDepth}.0 + d1; + float wTexR = wR * ${fSize * inputDepth}.0 + + wC * ${inputDepth}.0 + d1; + + float xValue = + getMatrixValueOrZeroPad(x, xShapeCR, vec2(xTexC, xTexR)); + + // Read w(wR, wC, d1, d2). + vec2 wUV = (vec2(wTexC, wTexR) + halfCR) / wShapeCR; + float wValue = texture2D(weights, wUV).r; + + dotProd += xValue * wValue; + } + } + } + if (${hasBias}) { + dotProd += getBiasValue(biases, d2); + } + gl_FragColor = vec4(dotProd, 0, 0, 0); + }`; +} + +export function getFragmentShaderGetBiasValueSource(outputDepth: number): + string { + return ` + float getBiasValue(in sampler2D bias, float biasC) { + const vec2 biasShapeCR = vec2(${outputDepth}, 1); + vec2 biasCR = vec2(mod(biasC, ${outputDepth}.0), 0); + vec2 biasUV = (biasCR + vec2(0.5, 0.5)) / biasShapeCR; + return texture2D(bias, biasUV).r; + }`; +} + +export function getFragmentShaderSource( + aShapeRowColDepth: [number, number, number], resultDepth: number, + fieldSize: number, stride: number, zeroPad: number, + hasBias: boolean): string { + const aShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const weightShapeRC: [number, number] = conv_util.computeWeightsTexShape( + aShapeRowColDepth[2], resultDepth, fieldSize); + + const prologue = getFragmentShaderPrologueSource(); + const getMatrixValueOrZeroPad = + getFragmentShaderGetMatrixValueOrZeroPadSource(); + const convolve = getFragmentShaderConvolveSource( + aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad, hasBias); + const getBiasValue = getFragmentShaderGetBiasValueSource(resultDepth); + + return [ + prologue, + getMatrixValueOrZeroPad, + getBiasValue, + convolve, + ].join('\n'); +} + +export function convolve( + gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, + weights: WebGLTexture, biases: WebGLTexture|null, result: WebGLTexture, + resultShapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(a, 'x', 0); + gpgpu.setInputMatrixTexture(weights, 'weights', 1); + if (biases != null) { + gpgpu.setInputMatrixTexture(biases, 'biases', 2); + } + gpgpu.executeProgram(); +} \ No newline at end of file diff --git a/src/math/webgl/conv_gpu_getbiasvalue_test.ts b/src/math/webgl/conv_gpu_getbiasvalue_test.ts new file mode 100644 index 0000000000..62046c36c7 --- /dev/null +++ b/src/math/webgl/conv_gpu_getbiasvalue_test.ts @@ -0,0 +1,85 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_gpu from './conv_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu getBiasValue', () => { + function createGetBiasValueProgram( + gpgpu: GPGPUContext, outputDepth: number): WebGLProgram { + const prologue = conv_gpu.getFragmentShaderPrologueSource(); + const uniforms = 'uniform float biasC;'; + const getBiasValue = + conv_gpu.getFragmentShaderGetBiasValueSource(outputDepth); + const main = ` + void main() { + gl_FragColor = vec4(getBiasValue(biases, biasC), 0, 0, 0); + }`; + + const src = [prologue, uniforms, getBiasValue, main].join('\n'); + return gpgpu.createProgram(src); + } + + function uploadGetBiasValueDownload( + biases: Float32Array, biasCol: number, outputDepth: number): number { + const gpgpu = new GPGPUContext(); + const program = createGetBiasValueProgram(gpgpu, outputDepth); + const biasesTex = gpgpu.createMatrixTexture(1, outputDepth); + const resultTex = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(biasesTex, 1, outputDepth, biases); + gpgpu.setOutputMatrixTexture(resultTex, 1, 1); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(biasesTex, 'biases', 2); + gpgpu.gl.uniform1f(gpgpu.getUniformLocation('biasC'), biasCol); + gpgpu.executeProgram(); + const result = gpgpu.downloadMatrixFromTexture(resultTex, 1, 1)[0]; + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(biasesTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + it('returns the only bias value if output depth is 1', () => { + const biases = new Float32Array([4]); + const result = uploadGetBiasValueDownload(biases, 0, 1); + expect(result).toEqual(4); + }); + + it('returns the requested column if < output depth', () => { + const biases = new Float32Array([1, 2, 3, 4, 5]); + const result = + uploadGetBiasValueDownload(biases, biases.length - 1, biases.length); + expect(result).toEqual(5); + }); + + it('wraps around to column 0 if column == output depth', () => { + const biases = new Float32Array([6, 0, 0]); + const result = uploadGetBiasValueDownload(biases, 3, 3); + expect(result).toEqual(6); + }); + + it('wraps around twice if column == 2*output depth', () => { + const biases = new Float32Array([7, 0, 0]); + const result = uploadGetBiasValueDownload(biases, 6, 3); + expect(result).toEqual(7); + }); + + it('selects value from column mod(biasC, outputDepth)', () => { + const biases = new Float32Array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]); + const result = uploadGetBiasValueDownload(biases, 2017, biases.length); + expect(result).toEqual(biases[2017 % biases.length]); + }); +}); diff --git a/src/math/webgl/conv_gpu_getmatrixvalueorzeropad_test.ts b/src/math/webgl/conv_gpu_getmatrixvalueorzeropad_test.ts new file mode 100644 index 0000000000..48d8c3d687 --- /dev/null +++ b/src/math/webgl/conv_gpu_getmatrixvalueorzeropad_test.ts @@ -0,0 +1,139 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_gpu from './conv_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu getMatrixValueOrZeroPad', () => { + function createGetMatrixValueOrZeroPadProgram( + gpgpu: GPGPUContext, shapeRowCol: [number, number]): WebGLProgram { + const prologue = conv_gpu.getFragmentShaderPrologueSource(); + + const uniformColRow = 'uniform vec2 colRow;'; + + const getMatrixValueOrZeroPad = + conv_gpu.getFragmentShaderGetMatrixValueOrZeroPadSource(); + + const main = ` + void main() { + const vec2 aShapeCR = vec2(${shapeRowCol[1]}, ${shapeRowCol[0]}); + float value = getMatrixValueOrZeroPad(x, aShapeCR, colRow); + gl_FragColor = vec4(value, 0, 0, 0); + }`; + + const src = + [prologue, uniformColRow, getMatrixValueOrZeroPad, main].join('\n'); + return gpgpu.createProgram(src); + } + + function uploadGetMatrixValueOrZeroPadDownload( + matrix: Float32Array, shapeRowCol: [number, number], + paramRowCol: [number, number]): number { + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const program: WebGLProgram = + createGetMatrixValueOrZeroPadProgram(gpgpu, shapeRowCol); + + const matrixTexture = + gpgpu.createMatrixTexture(shapeRowCol[0], shapeRowCol[1]); + const resultTexture = gpgpu.createMatrixTexture(1, 1); + + gpgpu.uploadMatrixToTexture( + matrixTexture, shapeRowCol[0], shapeRowCol[1], matrix); + + gpgpu.setOutputMatrixTexture(resultTexture, 1, 1); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(matrixTexture, 'x', 0); + const loc = gpgpu.getUniformLocation('colRow'); + gpgpu.gl.uniform2f(loc, paramRowCol[1], paramRowCol[0]); + gpgpu.executeProgram(); + const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteMatrixTexture(matrixTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; + } + + it('returns only value of a 1x1 matrix when row and column are 0', () => { + const a = new Float32Array([1.23]); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [1, 1], [0, 0]); + expect(result).toBeCloseTo(a[0]); + }); + + it('returns value of matrix cell at specified row and column', () => { + const a = new Float32Array(32 * 64); + a[5 + (30 * 64)] = Math.PI; + const result = uploadGetMatrixValueOrZeroPadDownload(a, [32, 64], [30, 5]); + expect(result).toBeCloseTo(Math.PI); + }); + + it('returns zero if sampling out-of-bounds left', () => { + const a = new Float32Array(4 * 4); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [4, 4], [0, -1]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds right', () => { + const a = new Float32Array(4 * 4); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [4, 4], [0, 15]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds top', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [-1, 0]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds bottom', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [20, 0]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds upper-left', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [-1, -1]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds upper-right', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [-1, 36]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds lower-left', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [20, -1]); + expect(result).toEqual(0); + }); + + it('returns zero if sampling out-of-bounds lower-right', () => { + const a = new Float32Array(19 * 35); + a.fill(1); + const result = uploadGetMatrixValueOrZeroPadDownload(a, [19, 35], [20, 36]); + expect(result).toEqual(0); + }); +}); diff --git a/src/math/webgl/conv_gpu_test.ts b/src/math/webgl/conv_gpu_test.ts new file mode 100644 index 0000000000..ac41c6a4ea --- /dev/null +++ b/src/math/webgl/conv_gpu_test.ts @@ -0,0 +1,413 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array1D, Array3D, Array4D, NDArray} from '../ndarray'; + +import * as conv_gpu from './conv_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +describe('conv_gpu', () => { + + function uploadConvolveDownload( + x: Float32Array, aShapeRowColDepth: [number, number, number], + weights: Float32Array, biases: Float32Array|null, resultDepth: number, + fieldSize: number, stride: number, zeroPad?: number): Float32Array { + zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad(aShapeRowColDepth, fieldSize, stride); + + const xTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + aShapeRowColDepth, fieldSize, resultDepth, stride, zeroPad); + + const weightsTexShapeRC: [number, number] = + conv_util.computeWeightsTexShape( + aShapeRowColDepth[2], resultDepth, fieldSize); + + const biasesTexShapeRC: [number, number] = [1, resultDepth]; + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = conv_gpu.getFragmentShaderSource( + aShapeRowColDepth, resultDepth, fieldSize, stride, zeroPad, + biases != null); + const program = gpgpu.createProgram(shaderSource); + + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + const weightsTex = + gpgpu.createMatrixTexture(weightsTexShapeRC[0], weightsTexShapeRC[1]); + const biasesTex = biases != null ? + gpgpu.createMatrixTexture(biasesTexShapeRC[0], biasesTexShapeRC[1]) : + null; + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(xTex, xTexShapeRC[0], xTexShapeRC[1], x); + gpgpu.uploadMatrixToTexture( + weightsTex, weightsTexShapeRC[0], weightsTexShapeRC[1], weights); + + if (biases != null) { + gpgpu.uploadMatrixToTexture( + biasesTex!, biasesTexShapeRC[0], biasesTexShapeRC[1], biases); + } + + conv_gpu.convolve( + gpgpu, program, xTex, weightsTex, biasesTex, resultTex, + resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + if (biasesTex != null) { + gpgpu.deleteMatrixTexture(biasesTex); + } + gpgpu.deleteMatrixTexture(weightsTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + function compareToCPU( + xShape: [number, number, number], fSize: number, resultDepth: number, + stride: number, pad: number) { + const x = NDArray.randNormal(xShape); + const weightsShape: [number, number, number, number] = + [fSize, fSize, xShape[2], resultDepth]; + const weights = NDArray.randNormal(weightsShape); + const biases = NDArray.randNormal([weightsShape[3]]); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = mathCPU.conv2d(x, weights, biases, stride, pad); + const yGPU = uploadConvolveDownload( + x.getValues(), xShape, weights.getValues(), biases.getValues(), + resultDepth, fSize, stride, pad); + + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('1x1x1 in, 1d out, 1x1 filter, 1 stride: [0] => [0]', () => { + const a = new Float32Array([0]); + const weights = new Float32Array([1]); + const biases = new Float32Array([0]); + const result = + uploadConvolveDownload(a, [1, 1, 1], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(0); + }); + + it('1x1x1 in, 1d out, 1x1 filter, 1 stride: [1] => [1]', () => { + const a = new Float32Array([1]); + const weights = new Float32Array([1]); + const biases = new Float32Array([0]); + const result = + uploadConvolveDownload(a, [1, 1, 1], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(1); + }); + + it('1x1x1 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([2]); + const weights = new Float32Array([3]); + const biases = new Float32Array([0]); + const result = + uploadConvolveDownload(a, [1, 1, 1], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(6); + }); + + it('1x1x1 in, 1d out, 1x1 filter, 1 stride, null bias', () => { + const a = new Float32Array([2]); + const weights = new Float32Array([3]); + const biases: Float32Array|null = null; + const result = + uploadConvolveDownload(a, [1, 1, 1], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(6); + }); + + it('1x1x1 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([2]); + const weights = new Float32Array([3]); + const biases = new Float32Array([Math.PI]); + const result = + uploadConvolveDownload(a, [1, 1, 1], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(6 + Math.PI); + }); + + it('1x1x2 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 1]); + const weights = new Float32Array([3, 5]); + const biases = new Float32Array([0, 0]); + const result = + uploadConvolveDownload(a, [1, 1, 2], weights, biases, 1, 1, 1); + expect(result).toBeCloseTo(8); + }); + + it('2x1x1 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2]); + const weights = new Float32Array([5]); + const biases = new Float32Array([0]); + const result = + uploadConvolveDownload(a, [2, 1, 1], weights, biases, 1, 1, 1); + expect(result.length).toEqual(2); + expect(result[0]).toBeCloseTo(5); + expect(result[1]).toBeCloseTo(10); + }); + + it('2x1x1 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2]); + const weights = new Float32Array([5]); + const biases = new Float32Array([Math.PI]); + const result = + uploadConvolveDownload(a, [2, 1, 1], weights, biases, 1, 1, 1); + expect(result.length).toEqual(2); + expect(result[0]).toBeCloseTo(5 + Math.PI); + expect(result[1]).toBeCloseTo(10 + Math.PI); + }); + + it('2x1x1 in, 2d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2]); + const weights = new Float32Array([5, 6]); + const biases = new Float32Array([0, 0]); + const result = + uploadConvolveDownload(a, [2, 1, 1], weights, biases, 2, 1, 1); + expect(result.length).toEqual(4); + expect(result[0]).toBeCloseTo(a[0] * weights[0]); + expect(result[1]).toBeCloseTo(a[0] * weights[1]); + expect(result[2]).toBeCloseTo(a[1] * weights[0]); + expect(result[3]).toBeCloseTo(a[1] * weights[1]); + }); + + it('2x1x1 in, 2d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2]); + const weights = new Float32Array([5, 6]); + const biases = new Float32Array([100, 200]); + const result = + uploadConvolveDownload(a, [2, 1, 1], weights, biases, 2, 1, 1); + expect(result.length).toEqual(4); + expect(result[0]).toBeCloseTo((a[0] * weights[0]) + biases[0]); + expect(result[1]).toBeCloseTo((a[0] * weights[1]) + biases[1]); + expect(result[2]).toBeCloseTo((a[1] * weights[0]) + biases[0]); + expect(result[3]).toBeCloseTo((a[1] * weights[1]) + biases[1]); + }); + + it('2x1x1 in, 3d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([2, 4]); + const weights = new Float32Array([3, 5, 7]); + const biases = new Float32Array([0, 0, 0]); + const result = + uploadConvolveDownload(a, [2, 1, 1], weights, biases, 3, 1, 1, 0); + expect(result.length).toEqual(2 * 3); + expect(result[0]).toBeCloseTo(a[0] * weights[0]); + expect(result[1]).toBeCloseTo(a[0] * weights[1]); + expect(result[2]).toBeCloseTo(a[0] * weights[2]); + expect(result[3]).toBeCloseTo(a[1] * weights[0]); + expect(result[4]).toBeCloseTo(a[1] * weights[1]); + expect(result[5]).toBeCloseTo(a[1] * weights[2]); + }); + + it('1x2x1 in, 1d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2]); + const weights = new Float32Array([5]); + const biases = new Float32Array([0]); + const result = + uploadConvolveDownload(a, [1, 2, 1], weights, biases, 1, 1, 1); + expect(result.length).toEqual(2); + expect(result[0]).toBeCloseTo(5); + expect(result[1]).toBeCloseTo(10); + }); + + it('2x1x2 in, 3d out, 1x1 filter, 1 stride', () => { + const a = new Float32Array([1, 2, 3, 4]); + const weights = new Float32Array([10, 11, 12, 13, 14, 15]); + const biases = new Float32Array([0, 0, 0]); + const result = + uploadConvolveDownload(a, [2, 1, 2], weights, biases, 3, 1, 1); + expect(result.length).toEqual(6); + expect(result[0]).toBeCloseTo(a[0] * weights[0] + a[1] * weights[3]); + expect(result[1]).toBeCloseTo(a[0] * weights[1] + a[1] * weights[4]); + expect(result[2]).toBeCloseTo(a[0] * weights[2] + a[1] * weights[5]); + expect(result[3]).toBeCloseTo(a[2] * weights[0] + a[3] * weights[3]); + expect(result[4]).toBeCloseTo(a[2] * weights[1] + a[3] * weights[4]); + expect(result[5]).toBeCloseTo(a[2] * weights[2] + a[3] * weights[5]); + }); + + it('2x2x1 in, 1d out, 2x2 filter, 1 stride', () => { + const x = new Float32Array([1, 2, 3, 4]); + const w = new Float32Array([3, 1, 5, 0]); + const bias = new Float32Array([0]); + const result = uploadConvolveDownload(x, [2, 2, 1], w, bias, 1, 2, 2, 1); + expect(result.length).toEqual(4); + expect(result[0]).toBe(0); + expect(result[1]).toBe(10); + expect(result[2]).toBe(3); + expect(result[3]).toBe(12); + }); + + it('2x2x1 in, 1d out, 2x2 filter, 1 stride', () => { + const x = new Float32Array([1, 2, 3, 4]); + const w = new Float32Array([3, 1, 5, 0]); + const bias = new Float32Array([-1]); + const result = uploadConvolveDownload(x, [2, 2, 1], w, bias, 1, 2, 1, 0); + expect(result.length).toEqual(1); + expect(result[0]).toBe(19); + }); + + it('2x2x1 in, 1d out, 2x2 filter, 1 stride, null bias', () => { + const x = new Float32Array([1, 2, 3, 4]); + const w = new Float32Array([3, 1, 5, 0]); + const bias: Float32Array|null = null; + const result = uploadConvolveDownload(x, [2, 2, 1], w, bias, 1, 2, 1, 0); + expect(result.length).toEqual(1); + expect(result[0]).toBe(20); + }); + + it('2x2x1 in, 1d out, 2x2 filter, 1 stride, zeropad = 1', () => { + const x = new Float32Array([1, 2, 3, 4]); + const w = new Float32Array([3, 1, 5, 0]); + const bias = new Float32Array([0]); + const result = uploadConvolveDownload(x, [2, 2, 1], w, bias, 1, 2, 2, 1); + expect(result.length).toEqual(4); + expect(result[0]).toBe(0); + expect(result[1]).toBe(10); + expect(result[2]).toBe(3); + expect(result[3]).toBe(12); + }); + + it('5x5x3 in, 2d out, 3x3 filter, 2 stride', () => { + /* + weights: input: + [ 1, -1, [1, 2, 2, 0, 0, 2, 2, 2, 1, 1, 2, 1, 1, 1, 2, + 1, 0, 1, 2, 2, 0, 2, 2, 1, 1, 0, 0, 2, 1, 1, 0, 1, + -1, 1, 2, 2, 0, 0, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, + -1, 0, 1, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 1, 0, 1, 2, + -1, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, 1, 0, 2, 0, 0, 0] + 0, 1, + -1, 1, biases: + 1, 1, [1, 0] + 1, 1, + 0, 1, + 0, 0, + 0, 1, + -1, -1, + 1, 0, + 1, -1, + 1, 1, + 1, 1, + 1, -1, + -1, 0, + 1, 0, + 0, 0, + 1, -1, + -1, -1, + 1, 0, + -1, 1, + 0, -1, + 0, 1] + */ + + const input = new Float32Array([ + 1, 2, 2, 0, 0, 2, 2, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 0, + 2, 2, 1, 1, 0, 0, 2, 1, 1, 0, 1, 2, 2, 0, 0, 2, 2, 1, 2, + 2, 2, 1, 2, 2, 2, 1, 1, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 1, + 0, 1, 2, 0, 0, 0, 0, 1, 0, 0, 2, 2, 1, 0, 2, 0, 0, 0 + ]); + + const weights = new Float32Array([ + 1, -1, 1, 0, -1, 1, -1, 0, -1, 0, 0, 1, -1, 1, 1, 1, 1, 1, + 0, 1, 0, 0, 0, 1, -1, -1, 1, 0, 1, -1, 1, 1, 1, 1, 1, -1, + -1, 0, 1, 0, 0, 0, 1, -1, -1, -1, 1, 0, -1, 1, 0, -1, 0, 1 + ]); + + const biases = new Float32Array([1, 0]); + + const result = + uploadConvolveDownload(input, [5, 5, 3], weights, biases, 2, 3, 2, 1); + /* + Filter centered at [0,0], zero-pad 1 column and 1 row + 0 0 0 0 0 0 0 0 0 + 0 0 0 1 2 2 0 0 2 + 0 0 0 1 2 2 0 2 2 + + Weights, column [0] + 1 1 -1 -1 -1 0 -1 1 1 + 0 0 0 -1 1 1 1 1 1 + -1 1 0 1 -1 1 -1 0 0 + + Element-wise product (dot product before summation) + 0 0 0 0 0 0 0 0 0 + 0 0 0 -1 2 2 0 0 2 + 0 0 0 1 -2 2 0 0 0 + + Sum of elements, plus bias of 1 + (-1 + 2 + 2 + 2 + 1 + -2 + 2) + 1 == 7 + */ + + expect(result[0]).toBeCloseTo(7); + + test_util.expectArraysClose( + result, + new Float32Array( + [7, -8, 8, -2, 7, -2, 5, 5, 4, 6, 1, 2, -1, 3, 7, -2, 1, 4]), + 0.00001); + }); + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 2; + const outputDepth = 1; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=1,d2=1,f=3,s=2,p=1', () => { + const inputDepth = 1; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 1; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=4,d2=3,f=2,s=1,p=0', () => { + const inputDepth = 4; + const inputShape: [number, number, number] = [8, 8, inputDepth]; + const fSize = 2; + const outputDepth = 3; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); + + it('matches CPU on random input, d1=3,d2=4,f=3,s=3,p=1', () => { + const inputDepth = 3; + const inputShape: [number, number, number] = [7, 7, inputDepth]; + const fSize = 3; + const outputDepth = 4; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, outputDepth, stride, zeroPad); + }); +}); diff --git a/src/math/webgl/copy_gpu.ts b/src/math/webgl/copy_gpu.ts new file mode 100644 index 0000000000..3210644704 --- /dev/null +++ b/src/math/webgl/copy_gpu.ts @@ -0,0 +1,63 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + sourceShapeRowCol: [number, number], sourceSizeRowCol: [number, number], + destSizeRowCol: [number, number]): string { + return ` + precision highp float; + uniform sampler2D source; + uniform vec2 sourceStartCR; + uniform vec2 destStartCR; + + const vec2 sourceShapeCR = + vec2(${sourceShapeRowCol[1]}, ${sourceShapeRowCol[0]}); + const vec2 sourceSizeCR = + vec2(${sourceSizeRowCol[1]}, ${sourceSizeRowCol[0]}); + const vec2 destSizeCR = + vec2(${destSizeRowCol[1]}, ${destSizeRowCol[0]}); + + void main() { + vec2 destOffsetCR = floor(gl_FragCoord.xy) - destStartCR; + float destOffsetFlat = (destOffsetCR.y * destSizeCR.x) + destOffsetCR.x; + vec2 sourceOffsetCR = vec2(mod(destOffsetFlat, sourceSizeCR.x), + floor(destOffsetFlat / sourceSizeCR.x)); + vec2 sourceCR = sourceStartCR + sourceOffsetCR; + vec2 sourceUV = (sourceCR + vec2(0.5, 0.5)) / sourceShapeCR; + gl_FragColor = texture2D(source, sourceUV); + }`; +} + +export function copy( + gpgpu: GPGPUContext, program: WebGLProgram, source: WebGLTexture, + sourceShapeRowCol: [number, number], sourceStartRowCol: [number, number], + sourceSizeRowCol: [number, number], dest: WebGLTexture, + destShapeRowCol: [number, number], destStartRowCol: [number, number], + destSizeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture(dest, destShapeRowCol[0], destShapeRowCol[1]); + gpgpu.setOutputMatrixWriteRegion( + destStartRowCol[0], destSizeRowCol[0], destStartRowCol[1], + destSizeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(source, 'source', 0); + const sourceStartCRLoc = gpgpu.getUniformLocation('sourceStartCR'); + gpgpu.gl.uniform2f( + sourceStartCRLoc, sourceStartRowCol[1], sourceStartRowCol[0]); + const destStartCRLoc = gpgpu.getUniformLocation('destStartCR'); + gpgpu.gl.uniform2f(destStartCRLoc, destStartRowCol[1], destStartRowCol[0]); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/copy_gpu_test.ts b/src/math/webgl/copy_gpu_test.ts new file mode 100644 index 0000000000..6600995f3b --- /dev/null +++ b/src/math/webgl/copy_gpu_test.ts @@ -0,0 +1,189 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as copy_gpu from './copy_gpu'; +import {GPGPUContext} from './gpgpu_context'; + +function uploadCopyDownload( + source: Float32Array, sourceShapeRowCol: [number, number], + sourceStartRowCol: [number, number], sourceSizeRowCol: [number, number], + destStartRowCol: [number, number], destSizeRowCol: [number, number], + dest: Float32Array, destShapeRowCol: [number, number]): Float32Array { + const gpgpu = new GPGPUContext(); + const fragmentShaderSource = copy_gpu.getFragmentShaderSource( + sourceShapeRowCol, sourceSizeRowCol, destSizeRowCol); + const program = gpgpu.createProgram(fragmentShaderSource); + + const sourceTex = + gpgpu.createMatrixTexture(sourceShapeRowCol[0], sourceShapeRowCol[1]); + const destTex = + gpgpu.createMatrixTexture(destShapeRowCol[0], destShapeRowCol[1]); + + gpgpu.uploadMatrixToTexture( + sourceTex, sourceShapeRowCol[0], sourceShapeRowCol[1], source); + gpgpu.uploadMatrixToTexture( + destTex, destShapeRowCol[0], destShapeRowCol[1], dest); + + copy_gpu.copy( + gpgpu, program, sourceTex, sourceShapeRowCol, sourceStartRowCol, + sourceSizeRowCol, destTex, destShapeRowCol, destStartRowCol, + destSizeRowCol); + + const result = gpgpu.downloadMatrixFromTexture( + destTex, destShapeRowCol[0], destShapeRowCol[1]); + + gpgpu.deleteMatrixTexture(sourceTex); + gpgpu.deleteMatrixTexture(destTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return result; +} + +describe('copy_gpu', () => { + it('copies a 1x1 source to a 1x1 dest', () => { + const source = new Float32Array([Math.PI]); + const dest = new Float32Array([0]); + const result = uploadCopyDownload( + source, [1, 1], [0, 0], [1, 1], [0, 0], [1, 1], dest, [1, 1]); + expect(result.length).toEqual(1); + expect(result[0]).toBeCloseTo(Math.PI); + }); + + it('copies a 1x2 source to a 1x2 dest', () => { + const source = new Float32Array([1, 2]); + const dest = new Float32Array([0, 0]); + const result = uploadCopyDownload( + source, [1, 2], [0, 0], [1, 2], [0, 0], [1, 2], dest, [1, 2]); + expect(result.length).toEqual(2); + expect(result[0]).toEqual(1); + expect(result[1]).toEqual(2); + }); + + it('copies a 2x1 source to a 2x1 dest', () => { + const source = new Float32Array([1, 2]); + const dest = new Float32Array([0, 0]); + const result = uploadCopyDownload( + source, [2, 1], [0, 0], [2, 1], [0, 0], [2, 1], dest, [2, 1]); + expect(result.length).toEqual(2); + expect(result[0]).toEqual(1); + expect(result[1]).toEqual(2); + }); + + it('copies a 2x2 source to a 2x2 dest', () => { + const source = new Float32Array([1, 2, 3, 4]); + const dest = new Float32Array([0, 0, 0, 0]); + const result = uploadCopyDownload( + source, [2, 2], [0, 0], [2, 2], [0, 0], [2, 2], dest, [2, 2]); + expect(result.length).toEqual(4); + expect(result[0]).toEqual(1); + expect(result[1]).toEqual(2); + expect(result[2]).toEqual(3); + expect(result[3]).toEqual(4); + }); + + it('copies inner 2x2 from a 4x4 source to a 2x2 dest', () => { + const source = new Float32Array(16); + source[5] = 10; + source[6] = 11; + source[9] = 12; + source[10] = 13; + const dest = new Float32Array(4); + const result = uploadCopyDownload( + source, [4, 4], [1, 1], [2, 2], [0, 0], [2, 2], dest, [2, 2]); + expect(result.length).toEqual(4); + expect(result[0]).toEqual(10); + expect(result[1]).toEqual(11); + expect(result[2]).toEqual(12); + expect(result[3]).toEqual(13); + }); + + it('copies a 1x4 row from source into a 2x2 dest', () => { + const source = new Float32Array([1, 2, 3, 4]); + const dest = new Float32Array(4); + const result = uploadCopyDownload( + source, [1, 4], [0, 0], [1, 4], [0, 0], [2, 2], dest, [2, 2]); + expect(result.length).toEqual(4); + expect(result[0]).toEqual(1); + expect(result[1]).toEqual(2); + expect(result[2]).toEqual(3); + expect(result[3]).toEqual(4); + }); + + it('copies a 1x4 row from source into a 4x1 dest', () => { + const source = new Float32Array([1, 2, 3, 4]); + const dest = new Float32Array(4); + const result = uploadCopyDownload( + source, [1, 4], [0, 0], [1, 4], [0, 0], [4, 1], dest, [4, 1]); + expect(result.length).toEqual(4); + expect(result[0]).toEqual(1); + expect(result[1]).toEqual(2); + expect(result[2]).toEqual(3); + expect(result[3]).toEqual(4); + }); + + it('copies a column from source into a dest row vector', () => { + const source = new Float32Array(10 * 10); + for (let i = 0; i < 10; ++i) { + source[3 + (i * 10)] = i + 1; + } + const dest = new Float32Array(10); + const result = uploadCopyDownload( + source, [10, 10], [0, 3], [10, 1], [0, 0], [1, 10], dest, [1, 10]); + test_util.expectArraysClose( + result, new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 0); + }); + + it('doesn\'t touch destination pixels outside of the source box', () => { + const source = new Float32Array([1]); + const dest = new Float32Array([Math.PI, 0]); + const result = uploadCopyDownload( + source, [1, 1], [0, 0], [1, 1], [0, 1], [1, 1], dest, [1, 2]); + expect(result[0]).toBeCloseTo(Math.PI); + expect(result[1]).toEqual(1); + }); + + it('accumulates results from previous copies into dest texture', () => { + const shapeRC: [number, number] = [10, 10]; + const sizeRC: [number, number] = [10, 1]; + const source = new Float32Array(100); + for (let i = 0; i < 100; ++i) { + source[i] = i; + } + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram( + copy_gpu.getFragmentShaderSource(shapeRC, sizeRC, sizeRC)); + const sourceTex = gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + const destTex = gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + gpgpu.uploadMatrixToTexture(sourceTex, shapeRC[0], shapeRC[1], source); + + for (let i = 0; i < 10; ++i) { + copy_gpu.copy( + gpgpu, program, sourceTex, shapeRC, [0, i], sizeRC, destTex, shapeRC, + [0, i], sizeRC); + } + + const dest = + gpgpu.downloadMatrixFromTexture(destTex, shapeRC[0], shapeRC[1]); + + gpgpu.deleteMatrixTexture(sourceTex); + gpgpu.deleteMatrixTexture(destTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + test_util.expectArraysClose(dest, source, 0); + }); +}); diff --git a/src/math/webgl/exp_gpu.ts b/src/math/webgl/exp_gpu.ts new file mode 100644 index 0000000000..2f10f909eb --- /dev/null +++ b/src/math/webgl/exp_gpu.ts @@ -0,0 +1,36 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getExpUnaryOp(): string { + return 'gl_FragColor = vec4(exp(value), 0, 0, 0);'; +} + +export function getFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getExpUnaryOp()); +} + +export function exp( + gpgpu: GPGPUContext, expProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, expProgram, a, rows, columns, result); +} + +export function uploadExpDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getExpUnaryOp()); +} diff --git a/src/math/webgl/exp_gpu_test.ts b/src/math/webgl/exp_gpu_test.ts new file mode 100644 index 0000000000..60048f7299 --- /dev/null +++ b/src/math/webgl/exp_gpu_test.ts @@ -0,0 +1,49 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as exp_gpu from './exp_gpu'; + +describe('exp_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(23 * 32); + const result = exp_gpu.uploadExpDownload(a, 23, 32); + expect(result.length).toEqual(a.length); + }); + + it('returns e when the only value in a 1x1 matrix is 1.0', () => { + const a = new Float32Array([1]); + const result = exp_gpu.uploadExpDownload(a, 1, 1); + expect(result[0]).toBeCloseTo(Math.E); + }); + + it('operates on every value in a matrix', () => { + const a = new Float32Array([1, 1, 1, 1, 1, 1]); + const result = exp_gpu.uploadExpDownload(a, 1, a.length); + const expected = new Float32Array(a.length); + expected.fill(Math.E); + test_util.expectArraysClose(result, expected, 0.0001); + }); + + it('calculates f(x)=e^x for every value in the matrix', () => { + const a = new Float32Array([0.5, 1, 2, -1]); + const result = exp_gpu.uploadExpDownload(a, 1, a.length); + const expected = new Float32Array(a.length); + for (let i = 0; i < a.length; ++i) { + expected[i] = Math.exp(a[i]); + } + test_util.expectArraysClose(result, expected, 0.0001); + }); +}); diff --git a/src/math/webgl/gpgpu_context.ts b/src/math/webgl/gpgpu_context.ts new file mode 100644 index 0000000000..fda586fa5b --- /dev/null +++ b/src/math/webgl/gpgpu_context.ts @@ -0,0 +1,310 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as gpgpu_util from './gpgpu_util'; +import * as tex_util from './tex_util'; +import * as webgl_util from './webgl_util'; + +import {WebGLLoseContextExtension} from './webgl_util'; + +export class GPGPUContext { + gl: WebGLRenderingContext; + textureFloatExtension: {}; + colorBufferFloatExtension: {}; + loseContextExtension: WebGLLoseContextExtension; + vertexBuffer: WebGLBuffer; + indexBuffer: WebGLBuffer; + framebuffer: WebGLFramebuffer; + outputTexture: WebGLTexture|null = null; + program: WebGLProgram|null = null; + private disposed = false; + private autoDebugValidate = false; + + constructor(gl?: WebGLRenderingContext) { + if (gl != null) { + this.gl = gl; + } else { + this.gl = gpgpu_util.createWebGLContext(); + } + + // WebGL 2.0 enables texture floats without an extension. + if (!webgl_util.isWebGL2Enabled()) { + this.textureFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'OES_texture_float'); + } else { + this.colorBufferFloatExtension = + webgl_util.getExtensionOrThrow(this.gl, 'EXT_color_buffer_float'); + } + + this.loseContextExtension = + webgl_util.getExtensionOrThrow(this.gl, 'WEBGL_lose_context') as + WebGLLoseContextExtension; + this.vertexBuffer = gpgpu_util.createVertexBuffer(this.gl); + this.indexBuffer = gpgpu_util.createIndexBuffer(this.gl); + this.framebuffer = webgl_util.createFramebuffer(this.gl); + } + + public dispose() { + this.throwIfDisposed(); + if (this.program != null) { + console.warn( + 'Disposing a GPGPUContext that still has a bound WebGLProgram.' + + ' This is probably a resource leak, delete the program with ' + + 'GPGPUContext.deleteProgram before disposing.'); + } + if (this.outputTexture != null) { + console.warn( + 'Disposing a GPGPUContext that still has a bound output matrix ' + + 'texture. This is probably a resource leak, delete the output ' + + 'matrix texture with GPGPUContext.deleteMatrixTexture before ' + + 'disposing.'); + } + const gl = this.gl; + webgl_util.callAndCheck(gl, () => gl.finish()); + webgl_util.callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null)); + webgl_util.callAndCheck(gl, () => gl.deleteFramebuffer(this.framebuffer)); + webgl_util.callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, null)); + webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.vertexBuffer)); + webgl_util.callAndCheck( + gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null)); + webgl_util.callAndCheck(gl, () => gl.deleteBuffer(this.indexBuffer)); + this.loseContextExtension.loseContext(); + this.disposed = true; + } + + public enableAutomaticDebugValidation(enabled: boolean) { + this.autoDebugValidate = enabled; + webgl_util.enableDebugWebGLErrorChecking(enabled); + } + + public createMatrixTexture(rows: number, columns: number): WebGLTexture { + this.throwIfDisposed(); + return gpgpu_util.createMatrixTexture(this.gl, rows, columns); + } + + public uploadPixelDataToTexture( + texture: WebGLTexture, + pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) { + this.throwIfDisposed(); + gpgpu_util.uploadPixelDataToTexture(this.gl, texture, pixels); + } + + public createPackedMatrixTexture(rows: number, columns: number): + WebGLTexture { + this.throwIfDisposed(); + return gpgpu_util.createPackedMatrixTexture(this.gl, rows, columns); + } + + public deleteMatrixTexture(texture: WebGLTexture) { + this.throwIfDisposed(); + if (this.outputTexture === texture) { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + this.outputTexture = null; + } + webgl_util.callAndCheck(this.gl, () => this.gl.deleteTexture(texture)); + } + + public uploadMatrixToTexture( + texture: WebGLTexture, rows: number, columns: number, + matrix: Float32Array) { + this.throwIfDisposed(); + const numChannels = 1; + return gpgpu_util.uploadMatrixToTexture( + this.gl, texture, rows, columns, matrix, numChannels); + } + + public uploadMatrixToPackedTexture( + texture: WebGLTexture, rows: number, columns: number, + matrix: Float32Array) { + this.throwIfDisposed(); + return gpgpu_util.uploadMatrixToPackedTexture( + this.gl, texture, rows, columns, matrix); + } + + public downloadMatrixFromTexture( + texture: WebGLTexture, rows: number, columns: number): Float32Array { + return this.downloadMatrixDriver( + texture, + () => + gpgpu_util.downloadMatrixFromOutputTexture(this.gl, rows, columns)); + } + + public downloadMatrixFromPackedTexture( + texture: WebGLTexture, rows: number, columns: number): Float32Array { + return this.downloadMatrixDriver( + texture, + () => gpgpu_util.downloadMatrixFromPackedOutputTexture( + this.gl, rows, columns)); + } + + public createProgram(fragmentShaderSource: string): WebGLProgram { + this.throwIfDisposed(); + const gl = this.gl; + const fragmentShader: WebGLShader = + webgl_util.createFragmentShader(gl, fragmentShaderSource); + const vertexShader: WebGLShader = gpgpu_util.createVertexShader(gl); + const program: WebGLProgram = webgl_util.createProgram(gl); + webgl_util.callAndCheck(gl, () => gl.attachShader(program, vertexShader)); + webgl_util.callAndCheck(gl, () => gl.attachShader(program, fragmentShader)); + webgl_util.linkProgram(gl, program); + if (this.autoDebugValidate) { + webgl_util.validateProgram(gl, program); + } + webgl_util.callAndCheck(gl, () => gl.detachShader(program, vertexShader)); + webgl_util.callAndCheck(gl, () => gl.deleteShader(vertexShader)); + webgl_util.callAndCheck(gl, () => gl.detachShader(program, fragmentShader)); + webgl_util.callAndCheck(gl, () => gl.deleteShader(fragmentShader)); + return program; + } + + public deleteProgram(program: WebGLProgram) { + this.throwIfDisposed(); + if (program === this.program) { + this.program = null; + } + if (program != null) { + webgl_util.callAndCheck(this.gl, () => this.gl.deleteProgram(program)); + } + } + + public setProgram(program: WebGLProgram|null) { + this.throwIfDisposed(); + this.program = program; + if ((this.program != null) && this.autoDebugValidate) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.callAndCheck(this.gl, () => this.gl.useProgram(program)); + } + + public getUniformLocation(uniformName: string): WebGLUniformLocation { + this.throwIfDisposed(); + this.throwIfNoProgram(); + return webgl_util.getProgramUniformLocationOrThrow( + this.gl, this.program!, uniformName); + } + + public setInputMatrixTexture( + inputMatrixTexture: WebGLTexture, uniformName: string, + textureUnit: number) { + this.throwIfDisposed(); + this.throwIfNoProgram(); + webgl_util.bindTextureToProgramUniformSampler( + this.gl, this.program!, inputMatrixTexture, uniformName, textureUnit); + } + + public setOutputMatrixTexture( + outputMatrixTexture: WebGLTexture, rows: number, columns: number) { + this.setOutputMatrixTextureDriver(outputMatrixTexture, columns, rows); + } + + public setOutputPackedMatrixTexture( + outputPackedMatrixTexture: WebGLTexture, rows: number, columns: number) { + this.throwIfDisposed(); + const [width, height] = + tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns); + this.setOutputMatrixTextureDriver(outputPackedMatrixTexture, width, height); + } + + public setOutputMatrixWriteRegion( + startRow: number, numRows: number, startColumn: number, + numColumns: number) { + this.setOutputMatrixWriteRegionDriver( + startColumn, startRow, numColumns, numRows); + } + + public setOutputPackedMatrixWriteRegion( + startRow: number, numRows: number, startColumn: number, + numColumns: number) { + throw new Error('setOutputPackedMatrixWriteRegion not implemented.'); + } + + public debugValidate() { + if (this.program != null) { + webgl_util.validateProgram(this.gl, this.program); + } + webgl_util.validateFramebuffer(this.gl); + } + + public executeProgram() { + this.throwIfDisposed(); + this.throwIfNoProgram(); + const gl = this.gl; + gpgpu_util.bindVertexProgramAttributeStreams( + gl, this.program!, this.vertexBuffer); + if (this.autoDebugValidate) { + this.debugValidate(); + } + webgl_util.callAndCheck( + gl, () => gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0)); + } + + public blockUntilAllProgramsCompleted() { + this.throwIfDisposed(); + webgl_util.callAndCheck(this.gl, () => this.gl.finish()); + } + + private downloadMatrixDriver( + texture: WebGLTexture, + downloadAndDecode: () => Float32Array): Float32Array { + this.throwIfDisposed(); + webgl_util.bindColorTextureToFramebuffer( + this.gl, texture, this.framebuffer); + const result = downloadAndDecode(); + if (this.outputTexture != null) { + webgl_util.bindColorTextureToFramebuffer( + this.gl, this.outputTexture, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(this.gl); + } + } else { + webgl_util.unbindColorTextureFromFramebuffer(this.gl, this.framebuffer); + } + return result; + } + + private setOutputMatrixTextureDriver( + outputMatrixTextureMaybePacked: WebGLTexture, width: number, + height: number) { + this.throwIfDisposed(); + const gl = this.gl; + webgl_util.bindColorTextureToFramebuffer( + gl, outputMatrixTextureMaybePacked, this.framebuffer); + if (this.autoDebugValidate) { + webgl_util.validateFramebuffer(gl); + } + this.outputTexture = outputMatrixTextureMaybePacked; + webgl_util.callAndCheck(gl, () => gl.viewport(0, 0, width, height)); + webgl_util.callAndCheck(gl, () => gl.scissor(0, 0, width, height)); + } + + private setOutputMatrixWriteRegionDriver( + x: number, y: number, width: number, height: number) { + this.throwIfDisposed(); + webgl_util.callAndCheck( + this.gl, () => this.gl.scissor(x, y, width, height)); + } + + private throwIfDisposed() { + if (this.disposed) { + throw new Error('Attempted to use disposed GPGPUContext.'); + } + } + + private throwIfNoProgram() { + if (this.program == null) { + throw new Error('No GPU program is currently set.'); + } + } +} diff --git a/src/math/webgl/gpgpu_context_test.ts b/src/math/webgl/gpgpu_context_test.ts new file mode 100644 index 0000000000..efc802fba4 --- /dev/null +++ b/src/math/webgl/gpgpu_context_test.ts @@ -0,0 +1,421 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import {GPGPUContext} from './gpgpu_context'; +import * as tex_util from './tex_util'; +import * as webgl_util from './webgl_util'; + +describe('GPGPUContext downloadMatrixFromTexture WebGL 2.0', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + texture = gpgpu.createMatrixTexture(1, 1); + }); + + afterEach(() => { + gpgpu.deleteMatrixTexture(texture); + gpgpu.dispose(); + }); + + it('returns clear color from the output texture', () => { + gpgpu.setOutputMatrixTexture(texture, 1, 1); + gpgpu.gl.clearColor(0.123, 0, 0, 0); + gpgpu.gl.clear(gpgpu.gl.COLOR_BUFFER_BIT); + const result = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(result[0]).toBeCloseTo(0.123); + }); + + it('returns matrix that was uploaded', () => { + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([1.234])); + const result = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(result[0]).toBeCloseTo(1.234); + }); + + it('uses texture parameter', () => { + const texture2: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([1])); + gpgpu.uploadMatrixToTexture(texture2, 1, 1, new Float32Array([2])); + const read1 = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + const read2 = gpgpu.downloadMatrixFromTexture(texture2, 1, 1); + expect(read1[0]).toBeCloseTo(1); + expect(read2[0]).toBeCloseTo(2); + gpgpu.deleteMatrixTexture(texture2); + }); +}); + +describe('GPGPUContext downloadMatrixFromTexture WebGL 1.0', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + webgl_util.preferWebGL1(); + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + texture = gpgpu.createMatrixTexture(1, 1); + }); + + afterEach(() => { + gpgpu.deleteMatrixTexture(texture); + gpgpu.dispose(); + webgl_util.preferWebGL2(); + }); + + it('returns clear color from the output texture', () => { + gpgpu.setOutputMatrixTexture(texture, 1, 1); + gpgpu.gl.clearColor(0.123, 0, 0, 0); + gpgpu.gl.clear(gpgpu.gl.COLOR_BUFFER_BIT); + const result = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(result[0]).toBeCloseTo(0.123); + }); + + it('returns matrix that was uploaded', () => { + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([1.234])); + const result = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(result[0]).toBeCloseTo(1.234); + }); + + it('uses texture parameter', () => { + const texture2: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([1])); + gpgpu.uploadMatrixToTexture(texture2, 1, 1, new Float32Array([2])); + const read1 = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + const read2 = gpgpu.downloadMatrixFromTexture(texture2, 1, 1); + expect(read1[0]).toBeCloseTo(1); + expect(read2[0]).toBeCloseTo(2); + gpgpu.deleteMatrixTexture(texture2); + }); +}); + +describe('GPGPUContext setOutputMatrixTexture WebGL 2.0', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + texture = gpgpu.createMatrixTexture(1, 1); + }); + + afterEach(() => { + gpgpu.deleteMatrixTexture(texture); + gpgpu.dispose(); + }); + + it('sets the output texture property to the output texture', () => { + gpgpu.setOutputMatrixTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBe(texture); + }); + + it('rebinds the output texture to the color buffer target', () => { + const output: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([10])); + gpgpu.setOutputMatrixTexture(output, 1, 1); + const tBeforeClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tBeforeClear[0]).toBeCloseTo(10); + gpgpu.gl.clearColor(1, 0, 0, 0); + gpgpu.gl.clear(gpgpu.gl.COLOR_BUFFER_BIT); + const tAfterClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tAfterClear[0]).toBeCloseTo(10); + gpgpu.deleteMatrixTexture(output); + }); + + it('resets output texture to null if nothing was previously bound', () => { + expect(gpgpu.outputTexture).toBeNull(); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBeNull(); + }); + + it('sets the gl viewport to the output texture dimensions', () => { + const columns = 456; + const rows = 123; + const output = gpgpu.createMatrixTexture(rows, columns); + gpgpu.setOutputMatrixTexture(output, rows, columns); + const expected = new Int32Array([0, 0, columns, rows]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); + + it('doesn\'t change gl viewport when downloading a non-output tex', () => { + const output = gpgpu.createMatrixTexture(128, 128); + gpgpu.setOutputMatrixTexture(output, 128, 128); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + const expected = new Int32Array([0, 0, 128, 128]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); +}); + +describe('GPGPUContext setOutputMatrixTexture WebGL 1.0', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + webgl_util.preferWebGL1(); + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + texture = gpgpu.createMatrixTexture(1, 1); + }); + + afterEach(() => { + webgl_util.preferWebGL2(); + gpgpu.deleteMatrixTexture(texture); + gpgpu.dispose(); + }); + + it('sets the output texture property to the output texture', () => { + gpgpu.setOutputMatrixTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBe(texture); + }); + + it('rebinds the output texture to the color buffer target', () => { + const output: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([10])); + gpgpu.setOutputMatrixTexture(output, 1, 1); + const tBeforeClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tBeforeClear[0]).toBeCloseTo(10); + gpgpu.gl.clearColor(1, 0, 0, 0); + gpgpu.gl.clear(gpgpu.gl.COLOR_BUFFER_BIT); + const tAfterClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tAfterClear[0]).toBeCloseTo(10); + gpgpu.deleteMatrixTexture(output); + }); + + it('resets output texture to null if nothing was previously bound', () => { + expect(gpgpu.outputTexture).toBeNull(); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBeNull(); + }); + + it('sets the gl viewport to the output texture dimensions', () => { + const columns = 456; + const rows = 123; + const output = gpgpu.createMatrixTexture(rows, columns); + gpgpu.setOutputMatrixTexture(output, rows, columns); + const expected = new Int32Array([0, 0, columns, rows]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); + + it('doesn\'t change gl viewport when downloading a non-output tex', () => { + const output = gpgpu.createMatrixTexture(128, 128); + gpgpu.setOutputMatrixTexture(output, 128, 128); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + const expected = new Int32Array([0, 0, 128, 128]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); +}); + +describe('GPGPUContext setOutputMatrixTexture WebGL 2.0', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + webgl_util.preferWebGL2(); + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + texture = gpgpu.createMatrixTexture(1, 1); + }); + + afterEach(() => { + gpgpu.deleteMatrixTexture(texture); + gpgpu.dispose(); + }); + + it('sets the output texture property to the output texture', () => { + gpgpu.setOutputMatrixTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBe(texture); + }); + + it('rebinds the output texture to the color buffer target', () => { + const output: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(texture, 1, 1, new Float32Array([10])); + gpgpu.setOutputMatrixTexture(output, 1, 1); + const tBeforeClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tBeforeClear[0]).toBeCloseTo(10); + gpgpu.gl.clearColor(1, 0, 0, 0); + gpgpu.gl.clear(gpgpu.gl.COLOR_BUFFER_BIT); + const tAfterClear = gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(tAfterClear[0]).toBeCloseTo(10); + gpgpu.deleteMatrixTexture(output); + }); + + it('resets output texture to null if nothing was previously bound', () => { + expect(gpgpu.outputTexture).toBeNull(); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBeNull(); + }); + + it('sets the gl viewport to the output texture dimensions', () => { + const columns = 456; + const rows = 123; + const output = gpgpu.createMatrixTexture(rows, columns); + gpgpu.setOutputMatrixTexture(output, rows, columns); + const expected = new Int32Array([0, 0, columns, rows]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); + + it('doesn\'t change gl viewport when downloading a non-output tex', () => { + const output = gpgpu.createMatrixTexture(128, 128); + gpgpu.setOutputMatrixTexture(output, 128, 128); + gpgpu.downloadMatrixFromTexture(texture, 1, 1); + const expected = new Int32Array([0, 0, 128, 128]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + gpgpu.deleteMatrixTexture(output); + }); +}); + +describe('GPGPUContext setOutputPackedMatrixTexture', () => { + let gpgpu: GPGPUContext; + let texture: WebGLTexture; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + }); + + afterEach(() => { + if (texture != null) { + gpgpu.deleteMatrixTexture(texture); + } + gpgpu.dispose(); + }); + + it('sets the output texture property to the output texture', () => { + texture = gpgpu.createPackedMatrixTexture(1, 1); + gpgpu.setOutputPackedMatrixTexture(texture, 1, 1); + expect(gpgpu.outputTexture).toBe(texture); + }); + + it('sets the gl viewport to the output packed texture dimensions', () => { + const columns = 456; + const rows = 123; + texture = gpgpu.createPackedMatrixTexture(rows, columns); + gpgpu.setOutputPackedMatrixTexture(texture, rows, columns); + const [width, height] = + tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns); + const expected = new Int32Array([0, 0, width, height]); + expect(gpgpu.gl.getParameter(gpgpu.gl.VIEWPORT)).toEqual(expected); + }); +}); + +describe('GPGPUContext setOutputMatrixWriteRegion', () => { + let gpgpu: GPGPUContext; + let program: WebGLProgram; + let output: WebGLTexture; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + const src = + 'precision highp float; void main() { gl_FragColor = vec4(2,0,0,0); }'; + program = gpgpu.createProgram(src); + output = gpgpu.createMatrixTexture(4, 4); + gpgpu.uploadMatrixToTexture(output, 4, 4, new Float32Array(16)); + gpgpu.setOutputMatrixTexture(output, 4, 4); + gpgpu.setProgram(program); + }); + + afterEach(() => { + gpgpu.deleteMatrixTexture(output); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + }); + + it('writes to all pixels by default', () => { + gpgpu.executeProgram(); + const result = gpgpu.downloadMatrixFromTexture(output, 4, 4); + const expected = new Float32Array(4 * 4); + expected.fill(2); + test_util.expectArraysClose(result, expected, 0); + }); + + it('sets the scissor box to the requested parameters', () => { + gpgpu.setOutputMatrixWriteRegion(0, 1, 2, 3); + const scissorBox = gpgpu.gl.getParameter(gpgpu.gl.SCISSOR_BOX); + expect(scissorBox[0]).toEqual(2); + expect(scissorBox[1]).toEqual(0); + expect(scissorBox[2]).toEqual(3); + expect(scissorBox[3]).toEqual(1); + }); + + it('writes only to center 2x2 region of 4x4 texture', () => { + gpgpu.setOutputMatrixWriteRegion(1, 2, 1, 2); + gpgpu.executeProgram(); + const result = gpgpu.downloadMatrixFromTexture(output, 4, 4); + const expected = + new Float32Array([0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0]); + test_util.expectArraysClose(result, expected, 0); + }); + + it('preserves data from previous writes outside of write region', () => { + gpgpu.setOutputMatrixWriteRegion(0, 1, 0, 4); // top row + gpgpu.executeProgram(); + gpgpu.setOutputMatrixWriteRegion(3, 1, 0, 4); // bottom row + gpgpu.executeProgram(); + const result = gpgpu.downloadMatrixFromTexture(output, 4, 4); + const expected = + new Float32Array([2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2]); + test_util.expectArraysClose(result, expected, 0); + }); + + it('writes adjacent cells across multiple calls', () => { + for (let row = 0; row < 4; ++row) { + for (let col = 0; col < 4; ++col) { + gpgpu.setOutputMatrixWriteRegion(row, 1, col, 1); + gpgpu.executeProgram(); + } + } + const result = gpgpu.downloadMatrixFromTexture(output, 4, 4); + const expected = new Float32Array(4 * 4); + expected.fill(2); + test_util.expectArraysClose(result, expected, 0); + }); +}); + +describe('GPGPUContext', () => { + let gpgpu: GPGPUContext; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + }); + + afterEach(() => { + gpgpu.dispose(); + }); + + it('throws an error if used after dispose', () => { + const gpgpuContext = new GPGPUContext(); + gpgpuContext.dispose(); + expect(gpgpuContext.dispose).toThrowError(); + }); + + it('throws an error if validation is on and framebuffer incomplete', () => { + const src = `precision highp float; void main() {}`; + const program = gpgpu.createProgram(src); + const result = gpgpu.createMatrixTexture(1, 1); + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(program); + gpgpu.deleteMatrixTexture(result); + expect(gpgpu.executeProgram).toThrowError(); + gpgpu.deleteProgram(program); + }); +}); diff --git a/src/math/webgl/gpgpu_util.ts b/src/math/webgl/gpgpu_util.ts new file mode 100644 index 0000000000..4132e1e6fe --- /dev/null +++ b/src/math/webgl/gpgpu_util.ts @@ -0,0 +1,258 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as tex_util from './tex_util'; +import * as webgl_util from './webgl_util'; + +export function getWebGLContextAttributes(): WebGLContextAttributes { + return { + alpha: false, + antialias: false, + premultipliedAlpha: false, + preserveDrawingBuffer: false, + depth: false, + stencil: false, + failIfMajorPerformanceCaveat: true + }; +} + +export function createWebGLContext(canvas?: HTMLCanvasElement) { + const attributes = getWebGLContextAttributes(); + let gl: WebGLRenderingContext; + if (canvas != null) { + gl = webgl_util.createWebGLRenderingContextFromCanvas(canvas, attributes); + } else { + gl = webgl_util.createWebGLRenderingContext(attributes); + } + webgl_util.callAndCheck(gl, () => gl.disable(gl.DEPTH_TEST)); + webgl_util.callAndCheck(gl, () => gl.disable(gl.STENCIL_TEST)); + webgl_util.callAndCheck(gl, () => gl.disable(gl.BLEND)); + webgl_util.callAndCheck(gl, () => gl.disable(gl.DITHER)); + webgl_util.callAndCheck(gl, () => gl.disable(gl.POLYGON_OFFSET_FILL)); + webgl_util.callAndCheck(gl, () => gl.disable(gl.SAMPLE_COVERAGE)); + webgl_util.callAndCheck(gl, () => gl.enable(gl.SCISSOR_TEST)); + webgl_util.callAndCheck(gl, () => gl.enable(gl.CULL_FACE)); + webgl_util.callAndCheck(gl, () => gl.cullFace(gl.BACK)); + return gl; +} + +export function createVertexShader(gl: WebGLRenderingContext): WebGLShader { + const vertexShaderSource = ` + precision highp float; + attribute vec3 clipSpacePos; + attribute vec2 uv; + varying vec2 resultUV; + + void main() { + gl_Position = vec4(clipSpacePos, 1); + resultUV = uv; + }`; + return webgl_util.createVertexShader(gl, vertexShaderSource); +} + +export function createVertexBuffer(gl: WebGLRenderingContext): WebGLBuffer { + // [x y z u v] * [upper-left, lower-left, upper-right, lower-right] + const vertexArray = new Float32Array( + [-1, 1, 0, 0, 1, -1, -1, 0, 0, 0, 1, 1, 0, 1, 1, 1, -1, 0, 1, 0]); + return webgl_util.createStaticVertexBuffer(gl, vertexArray); +} + +export function createIndexBuffer(gl: WebGLRenderingContext): WebGLBuffer { + // OpenGL (and WebGL) have "CCW == front" winding + const triangleVertexIndices = new Uint16Array([0, 1, 2, 2, 1, 3]); + return webgl_util.createStaticIndexBuffer(gl, triangleVertexIndices); +} + +function getTextureInternalFormat( + gl: WebGLRenderingContext, numChannels: number): number { + if (webgl_util.isWebGL2Enabled()) { + if (numChannels === 4) { + // tslint:disable-next-line:no-any + return (gl as any).RGBA32F; + } + // tslint:disable-next-line:no-any + return (gl as any).R32F; + } + return gl.RGBA; +} + +function getTextureFormat( + gl: WebGLRenderingContext, numChannels: number): number { + if (webgl_util.isWebGL2Enabled() && numChannels === 1) { + // tslint:disable-next-line:no-any + return (gl as any).RED; + } + return gl.RGBA; +} + +function createAndConfigureTexture( + gl: WebGLRenderingContext, width: number, height: number, + numChannels: number): WebGLTexture { + webgl_util.validateTextureSize(gl, width, height); + const texture = webgl_util.createTexture(gl); + + const tex2d = gl.TEXTURE_2D; + const internalFormat = getTextureInternalFormat(gl, numChannels); + const format = getTextureFormat(gl, numChannels); + webgl_util.callAndCheck(gl, () => gl.bindTexture(tex2d, texture)); + webgl_util.callAndCheck( + gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)); + webgl_util.callAndCheck( + gl, () => gl.texParameteri(tex2d, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)); + webgl_util.callAndCheck( + gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MIN_FILTER, gl.NEAREST)); + webgl_util.callAndCheck( + gl, () => gl.texParameteri(tex2d, gl.TEXTURE_MAG_FILTER, gl.NEAREST)); + webgl_util.callAndCheck( + gl, + () => gl.texImage2D( + tex2d, 0, internalFormat, width, height, 0, format, gl.FLOAT, null)); + webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null)); + return texture; +} + +export function createMatrixTexture( + gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture { + const [width, height] = + tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns); + const numChannels = 1; + return createAndConfigureTexture(gl, width, height, numChannels); +} + +export function createColorMatrixTexture( + gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture { + const [width, height] = + tex_util.getColorMatrixTextureShapeWidthHeight(rows, columns); + const numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} + +export function createPackedMatrixTexture( + gl: WebGLRenderingContext, rows: number, columns: number): WebGLTexture { + const [width, height] = + tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns); + const numChannels = 4; + return createAndConfigureTexture(gl, width, height, numChannels); +} + +export function bindVertexProgramAttributeStreams( + gl: WebGLRenderingContext, program: WebGLProgram, + vertexBuffer: WebGLBuffer) { + const posOffset = 0; // x is the first buffer element + const uvOffset = 3 * 4; // uv comes after [x y z] + const stride = (3 * 4) + (2 * 4); // xyz + uv, each entry is 4-byte float. + webgl_util.callAndCheck( + gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer)); + webgl_util.bindVertexBufferToProgramAttribute( + gl, program, 'clipSpacePos', vertexBuffer, 3, stride, posOffset); + try { + webgl_util.bindVertexBufferToProgramAttribute( + gl, program, 'uv', vertexBuffer, 2, stride, uvOffset); + } catch (e) { + // Programs with 1x1 output textures don't use the uv attribute. + // This can cause the shader linker to dead-strip it, so we shouldn't + // complain or fail if it's not present. + if (!e.hasOwnProperty('namedVertexAttributeNotFound')) { + throw e; + } + } +} + +export function uploadPixelDataToTexture( + gl: WebGLRenderingContext, texture: WebGLTexture, + pixels: ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement) { + const numChannels = 4; + const internalFormat = getTextureInternalFormat(gl, numChannels); + webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture)); + webgl_util.callAndCheck( + gl, + () => gl.texImage2D( + gl.TEXTURE_2D, 0, internalFormat, gl.RGBA, gl.FLOAT, pixels)); + webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null)); +} + +function uploadDataToTexture( + gl: WebGLRenderingContext, texture: WebGLTexture, width: number, + height: number, data: Float32Array, numChannels: number) { + const textureFormat = getTextureFormat(gl, numChannels); + + webgl_util.validateTextureSize(gl, width, height); + webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture)); + webgl_util.callAndCheck( + gl, + () => gl.texSubImage2D( + gl.TEXTURE_2D, 0, 0, 0, width, height, textureFormat, gl.FLOAT, + data)); + webgl_util.callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null)); +} + +export function uploadMatrixToTexture( + gl: WebGLRenderingContext, texture: WebGLTexture, rows: number, + columns: number, matrix: Float32Array, numChannels: number) { + const [w, h] = + tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns); + + const channelsPerTexture = + numChannels === 1 ? webgl_util.getChannelsPerTexture() : numChannels; + const unpackedArray = + new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize( + matrix.length, channelsPerTexture)); + tex_util.encodeMatrixToUnpackedArray( + matrix, unpackedArray, channelsPerTexture); + + uploadDataToTexture(gl, texture, w, h, unpackedArray, numChannels); +} + +export function uploadMatrixToPackedTexture( + gl: WebGLRenderingContext, texture: WebGLTexture, rows: number, + columns: number, matrix: Float32Array) { + const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns); + const packedRGBA = new Float32Array( + tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + tex_util.encodeMatrixToPackedRGBA(matrix, rows, columns, packedRGBA); + const numChannels = 4; + uploadDataToTexture(gl, texture, w, h, packedRGBA, numChannels); +} + +export function downloadMatrixFromOutputTexture( + gl: WebGLRenderingContext, rows: number, columns: number): Float32Array { + const [w, h] = + tex_util.getUnpackedMatrixTextureShapeWidthHeight(rows, columns); + + const channelsPerTexture = 4; + const unpackedArray = + new Float32Array(tex_util.getUnpackedArraySizeFromMatrixSize( + rows * columns, channelsPerTexture)); + const textureFormat = getTextureFormat(gl, channelsPerTexture); + + webgl_util.callAndCheck( + gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, unpackedArray)); + + const matrix = new Float32Array(rows * columns); + tex_util.decodeMatrixFromUnpackedArray( + unpackedArray, matrix, channelsPerTexture); + return matrix; +} + +export function downloadMatrixFromPackedOutputTexture( + gl: WebGLRenderingContext, rows: number, columns: number): Float32Array { + const [w, h] = tex_util.getPackedMatrixTextureShapeWidthHeight(rows, columns); + const packedRGBA = new Float32Array( + tex_util.getPackedRGBAArraySizeFromMatrixShape(rows, columns)); + webgl_util.callAndCheck( + gl, () => gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, packedRGBA)); + const matrix = new Float32Array(rows * columns); + return tex_util.decodeMatrixFromPackedRGBA(packedRGBA, rows, columns, matrix); +} diff --git a/src/math/webgl/gpgpu_util_test.ts b/src/math/webgl/gpgpu_util_test.ts new file mode 100644 index 0000000000..b7499d076e --- /dev/null +++ b/src/math/webgl/gpgpu_util_test.ts @@ -0,0 +1,117 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as gpgpu_util from './gpgpu_util'; + +describe('gpgpu_util createWebGLContext', () => { + let gpgpu: GPGPUContext; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + }); + + afterEach(() => { + gpgpu.dispose(); + }); + + it('disables DEPTH_TEST and STENCIL_TEST', () => { + expect(gpgpu.gl.getParameter(gpgpu.gl.DEPTH_TEST)).toEqual(false); + expect(gpgpu.gl.getParameter(gpgpu.gl.STENCIL_TEST)).toEqual(false); + }); + + it('disables BLEND', () => { + expect(gpgpu.gl.getParameter(gpgpu.gl.BLEND)).toEqual(false); + }); + + it('disables DITHER, POLYGON_OFFSET_FILL', () => { + expect(gpgpu.gl.getParameter(gpgpu.gl.DITHER)).toEqual(false); + expect(gpgpu.gl.getParameter(gpgpu.gl.POLYGON_OFFSET_FILL)).toEqual(false); + }); + + it('enables CULL_FACE with BACK', () => { + expect(gpgpu.gl.getParameter(gpgpu.gl.CULL_FACE)).toEqual(true); + expect(gpgpu.gl.getParameter(gpgpu.gl.CULL_FACE_MODE)) + .toEqual(gpgpu.gl.BACK); + }); + + it('enables SCISSOR_TEST', () => { + expect(gpgpu.gl.getParameter(gpgpu.gl.SCISSOR_TEST)).toEqual(true); + }); +}); + +describe('gpgpu_util createMatrixTexture', () => { + it('sets the TEXTURE_WRAP S+T parameters to CLAMP_TO_EDGE', () => { + const gpgpu = new GPGPUContext(); + const tex = gpgpu_util.createMatrixTexture(gpgpu.gl, 32, 32); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, tex); + expect( + gpgpu.gl.getTexParameter(gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_WRAP_S)) + .toEqual(gpgpu.gl.CLAMP_TO_EDGE); + expect( + gpgpu.gl.getTexParameter(gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_WRAP_T)) + .toEqual(gpgpu.gl.CLAMP_TO_EDGE); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, null); + gpgpu.deleteMatrixTexture(tex); + gpgpu.dispose(); + }); + + it('sets the TEXTURE_[MIN|MAG]_FILTER parameters to NEAREST', () => { + const gpgpu = new GPGPUContext(); + const tex = gpgpu_util.createMatrixTexture(gpgpu.gl, 32, 32); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, tex); + expect(gpgpu.gl.getTexParameter( + gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_MIN_FILTER)) + .toEqual(gpgpu.gl.NEAREST); + expect(gpgpu.gl.getTexParameter( + gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_MAG_FILTER)) + .toEqual(gpgpu.gl.NEAREST); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, null); + gpgpu.deleteMatrixTexture(tex); + gpgpu.dispose(); + }); +}); + +describe('gpgpu_util createPackedMatrixTexture', () => { + it('sets the TEXTURE_WRAP S+T parameters to CLAMP_TO_EDGE', () => { + const gpgpu = new GPGPUContext(); + const tex = gpgpu_util.createPackedMatrixTexture(gpgpu.gl, 32, 32); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, tex); + expect( + gpgpu.gl.getTexParameter(gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_WRAP_S)) + .toEqual(gpgpu.gl.CLAMP_TO_EDGE); + expect( + gpgpu.gl.getTexParameter(gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_WRAP_T)) + .toEqual(gpgpu.gl.CLAMP_TO_EDGE); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, null); + gpgpu.deleteMatrixTexture(tex); + gpgpu.dispose(); + }); + + it('sets the TEXTURE_[MIN|MAG]_FILTER parameters to NEAREST', () => { + const gpgpu = new GPGPUContext(); + const tex = gpgpu_util.createPackedMatrixTexture(gpgpu.gl, 32, 32); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, tex); + expect(gpgpu.gl.getTexParameter( + gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_MIN_FILTER)) + .toEqual(gpgpu.gl.NEAREST); + expect(gpgpu.gl.getTexParameter( + gpgpu.gl.TEXTURE_2D, gpgpu.gl.TEXTURE_MAG_FILTER)) + .toEqual(gpgpu.gl.NEAREST); + gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D, null); + gpgpu.deleteMatrixTexture(tex); + gpgpu.dispose(); + }); +}); diff --git a/src/math/webgl/log_gpu.ts b/src/math/webgl/log_gpu.ts new file mode 100644 index 0000000000..19426bc338 --- /dev/null +++ b/src/math/webgl/log_gpu.ts @@ -0,0 +1,36 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getLogUnaryOp(): string { + return 'gl_FragColor = vec4(log(value), 0, 0, 0);'; +} + +export function getFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getLogUnaryOp()); +} + +export function log( + gpgpu: GPGPUContext, logProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, logProgram, a, rows, columns, result); +} + +export function uploadLogDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getLogUnaryOp()); +} diff --git a/src/math/webgl/log_gpu_test.ts b/src/math/webgl/log_gpu_test.ts new file mode 100644 index 0000000000..c140046cd2 --- /dev/null +++ b/src/math/webgl/log_gpu_test.ts @@ -0,0 +1,50 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as log_gpu from './log_gpu'; + +describe('log_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(23 * 32); + const result = log_gpu.uploadLogDownload(a, 23, 32); + expect(result.length).toEqual(a.length); + }); + + it('returns 1.0 when the only value in a 1x1 matrix is e', () => { + const a = new Float32Array([Math.E]); + const result = log_gpu.uploadLogDownload(a, 1, 1); + expect(result[0]).toBeCloseTo(1.0); + }); + + it('operates on every value in a matrix', () => { + const a = new Float32Array(6); + a.fill(Math.E); + const result = log_gpu.uploadLogDownload(a, 1, a.length); + const expected = new Float32Array(a.length); + expected.fill(1.0); + test_util.expectArraysClose(result, expected, 0.0001); + }); + + it('calculates f(x)=ln x for every value in the matrix', () => { + const a = new Float32Array([0.5, 1, 2, 3]); + const result = log_gpu.uploadLogDownload(a, 1, a.length); + const expected = new Float32Array(a.length); + for (let i = 0; i < a.length; ++i) { + expected[i] = Math.log(a[i]); + } + test_util.expectArraysClose(result, expected, 0.0001); + }); +}); diff --git a/src/math/webgl/logsumexp_gpu.ts b/src/math/webgl/logsumexp_gpu.ts new file mode 100644 index 0000000000..b3e832e67d --- /dev/null +++ b/src/math/webgl/logsumexp_gpu.ts @@ -0,0 +1,73 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource(rows: number, columns: number): string { + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 resultUV; + + const vec2 aDimCR = vec2(${columns}.0, ${rows}.0); + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + float aMax = texture2D(matrixA, halfCR / aDimCR).r; + for (float r = 0.0; r < aDimCR.y; r += 1.0) { + for (float c = 0.0; c < aDimCR.x; c += 1.0) { + vec2 uv = (vec2(c, r) + halfCR) / aDimCR; + float aCur = texture2D(matrixA, uv).r; + aMax = max(aMax, aCur); + } + } + + float expSum = 0.0; + for (float r = 0.0; r < aDimCR.y; r += 1.0) { + for (float c = 0.0; c < aDimCR.x; c += 1.0) { + vec2 uv = (vec2(c, r) + halfCR) / aDimCR; + float aCur = texture2D(matrixA, uv).r; + expSum += exp(aCur - aMax); + } + } + + gl_FragColor = vec4(aMax + log(expSum), 0, 0, 0); + }`; +} + +export function logSumExp( + gpgpu: GPGPUContext, logSumExpProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(logSumExpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} + +export function uploadLogSumExpDownload( + a: Float32Array, rows: number, columns: number): number { + const gpgpu = new GPGPUContext(); + const program = gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + const aTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + logSumExp(gpgpu, program, aTexture, rows, columns, resultTexture); + const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result[0]; +} diff --git a/src/math/webgl/logsumexp_gpu_test.ts b/src/math/webgl/logsumexp_gpu_test.ts new file mode 100644 index 0000000000..2c5cc3d25c --- /dev/null +++ b/src/math/webgl/logsumexp_gpu_test.ts @@ -0,0 +1,54 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as logsumexp_gpu from './logsumexp_gpu'; + +function cpuLogSumExp(m: Float32Array): number { + if (m.length === 0) { + throw new Error('m must have length greater than zero.'); + } + let mMax = m[0]; + for (let i = 0; i < m.length; ++i) { + mMax = Math.max(mMax, m[i]); + } + let expSum = 0; + for (let i = 0; i < m.length; ++i) { + expSum += Math.exp(m[i] - mMax); + } + const logSumExp = mMax + Math.log(expSum); + return logSumExp; +} + +describe('logsumexp_gpu', () => { + it('returns 0 (ln(1) = 0) when the 1x1 input matrix is [0]', () => { + const a = new Float32Array([0]); + const result = logsumexp_gpu.uploadLogSumExpDownload(a, 1, 1); + expect(result).toEqual(0); + }); + + it('returns ln(length) when the input matrix is [0]', () => { + const a = new Float32Array(512 * 512); + const result = logsumexp_gpu.uploadLogSumExpDownload(a, 512, 512); + expect(result).toBeCloseTo(Math.log(a.length)); + }); + + it('computes the same result as cpuLogSumExp', () => { + const a = test_util.randomArrayInRange(12 * 29, -2, 2); + const result = logsumexp_gpu.uploadLogSumExpDownload(a, 12, 29); + const expected = cpuLogSumExp(a); + expect(result).toBeCloseTo(expected); + }); +}); diff --git a/src/math/webgl/max_pool_backprop_gpu.ts b/src/math/webgl/max_pool_backprop_gpu.ts new file mode 100644 index 0000000000..97c2e59c33 --- /dev/null +++ b/src/math/webgl/max_pool_backprop_gpu.ts @@ -0,0 +1,101 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderMaxPoolBackprop( + dyShapeRCD: [number, number, number], fSize: number, origStride: number, + origPad: number) { + const origInputDepth = dyShapeRCD[2]; + const pad = fSize - 1 - origPad; + const [dyRows, dyCols, depth] = dyShapeRCD; + + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dyShapeRCD); + + return ` + precision highp float; + uniform sampler2D dy; + uniform sampler2D maxPos; + + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 dyShapeCR = vec2(${dyTexShapeRC[1]}, ${dyTexShapeRC[0]}); + + void main() { + vec2 dxTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (dxTexR, dxTexC) to 3D (dxR, dxC, d). + float dxR = dxTexCR.y; + float dxC = floor(dxTexCR.x / ${origInputDepth}.0); + float d = mod(dxTexCR.x, ${origInputDepth}.0); + + vec2 dyRCCorner = vec2(dxR, dxC) - vec2(${pad}.0, ${pad}.0); + float dyRCorner = dyRCCorner.x; + float dyCCorner = dyRCCorner.y; + + // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(yR, dxC, d). + // ? = to be determined. : = across all values in that axis. + float dotProd = 0.0; + for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) { + + float dyR = (dyRCorner + wR) / ${origStride}.0; + // TODO(nsthorat): Splice this with another version where you call + // getMatrixValueOrZeroPad(). Here and below. + if (dyR < 0.0 || dyR >= ${dyRows}.0 || fract(dyR) > 0.0) { + continue; + } + + float dyTexR = dyR; + + for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) { + + float dyC = (dyCCorner + wC) / ${origStride}.0; + if (dyC < 0.0 || dyC >= ${dyCols}.0 || fract(dyC) > 0.0) { + continue; + } + + float dyTexC = dyC * ${depth}.0 + d; + + // Read dy(dyR, dyC, d). + vec2 dyUV = (vec2(dyTexC, dyTexR) + halfCR) / dyShapeCR; + float dyValue = texture2D(dy, dyUV).r; + + // Read maxPos(dyR, dyC, d). + float maxPosValue = + ${fSize * fSize - 1}.0 - texture2D(maxPos, dyUV).r; + + // Get the current value, check it against the value from the + // position matrix. + float curPosValue = wR * ${fSize}.0 + wC; + float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0); + + dotProd += dyValue * mask; + } + } + gl_FragColor = vec4(dotProd, 0, 0, 0); + }`; +} + +export function maxPoolBackprop( + gpgpu: GPGPUContext, program: WebGLProgram, dyTex: WebGLTexture, + maxPositionsTex: WebGLTexture, resultTex: WebGLTexture, + resultTexShapeRC: [number, number]) { + gpgpu.setOutputMatrixTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(dyTex, 'dy', 0); + gpgpu.setInputMatrixTexture(maxPositionsTex, 'maxPos', 1); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/max_pool_backprop_gpu_test.ts b/src/math/webgl/max_pool_backprop_gpu_test.ts new file mode 100644 index 0000000000..96bc896e9b --- /dev/null +++ b/src/math/webgl/max_pool_backprop_gpu_test.ts @@ -0,0 +1,141 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MaxPool} from '../../ops/max_pool'; +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as max_pool_backprop_gpu from './max_pool_backprop_gpu'; +import * as max_pool_gpu from './max_pool_gpu'; + +describe('max_pool_backprop_gpu', () => { + + function uploadMaxPoolBackpropDownload( + dy: Array3D, x: Array3D, fSize: number, origStride: number, + origPad: number): Float32Array { + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const depth = dy.shape[2]; + const src = max_pool_backprop_gpu.getFragmentShaderMaxPoolBackprop( + dy.shape, fSize, origStride, origPad); + const program = gpgpu.createProgram(src); + + // Upload dy. + const dyTexShapeRC = conv_util.computeTexShapeFrom3D(dy.shape); + const dyTex = gpgpu.createMatrixTexture(dyTexShapeRC[0], dyTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + dyTex, dyTexShapeRC[0], dyTexShapeRC[1], dy.getValues()); + + // Upload x. + const xTexShapeRC = conv_util.computeTexShapeFrom3D(x.shape); + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + xTex, xTexShapeRC[0], xTexShapeRC[1], x.getValues()); + + // Compute max positions. + const maxPoolResultShape = conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], origStride, origPad); + const maxPoolResultTexShape = + conv_util.computeTexShapeFrom3D(maxPoolResultShape); + const maxPoolPositionsResultTex = gpgpu.createMatrixTexture( + maxPoolResultTexShape[0], maxPoolResultTexShape[1]); + const maxPoolPositionsSrc = + max_pool_gpu.getFragmentShaderMaxPoolPositionsSource( + x.shape, fSize, origStride, origPad); + const maxPoolPositionsProgram = gpgpu.createProgram(maxPoolPositionsSrc); + max_pool_gpu.maxPoolCommon( + gpgpu, maxPoolPositionsProgram, xTex, maxPoolPositionsResultTex, + maxPoolResultTexShape); + + // Figure out the output shape by dilating the input. + const dyRowsDilated = (dy.shape[0] - 1) * origStride + 1; + const dyColsDilated = (dy.shape[1] - 1) * origStride + 1; + const pad = fSize - 1 - origPad; + const resultShapeRCD = conv_util.computeOutputShape3D( + [dyRowsDilated, dyColsDilated, depth], fSize, depth, 1, pad); + const resultTexRC = conv_util.computeTexShapeFrom3D(resultShapeRCD); + const resultTex = gpgpu.createMatrixTexture(resultTexRC[0], resultTexRC[1]); + max_pool_backprop_gpu.maxPoolBackprop( + gpgpu, program, dyTex, maxPoolPositionsResultTex, resultTex, + resultTexRC); + const y = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexRC[0], resultTexRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(dyTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return y; + } + + function compareToCPU( + dyShape: [number, number, number], xShape: [number, number, number], + fSize: number, origStride: number, origPad: number) { + const dy = NDArray.randNormal(dyShape); + const x = NDArray.randNormal(xShape); + + const mathCPU = new NDArrayMathCPU(); + const dxCPU = mathCPU.maxPoolBackprop(dy, x, fSize, origStride, origPad); + const dxGPU = + uploadMaxPoolBackpropDownload(dy, x, fSize, origStride, origPad); + test_util.expectArraysClose(dxGPU, dxCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const depth = 1; + const dyShape: [number, number, number] = [8, 8, depth]; + const xShape: [number, number, number] = [9, 9, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(dyShape, xShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=1,f=3,s=2,p=1', () => { + const depth = 1; + const dyShape: [number, number, number] = [7, 7, depth]; + const xShape: [number, number, number] = [13, 13, depth]; + const fSize = 3; + const stride = 2; + const zeroPad = 1; + compareToCPU(dyShape, xShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=4,f=2,s=1,p=0', () => { + const depth = 4; + const dyShape: [number, number, number] = [8, 8, depth]; + const xShape: [number, number, number] = [9, 9, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(dyShape, xShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=3,f=3,s=3,p=0', () => { + const depth = 3; + const dyShape: [number, number, number] = [7, 7, depth]; + const xShape: [number, number, number] = [21, 21, depth]; + const fSize = 3; + const stride = 3; + const zeroPad = 0; + compareToCPU(dyShape, xShape, fSize, stride, zeroPad); + }); +}); diff --git a/src/math/webgl/max_pool_gpu.ts b/src/math/webgl/max_pool_gpu.ts new file mode 100644 index 0000000000..7cac3f68fc --- /dev/null +++ b/src/math/webgl/max_pool_gpu.ts @@ -0,0 +1,44 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as pool_gpu from './pool_gpu'; + +export function getFragmentShaderMaxPoolPositionsSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number) { + return getFragmentShaderMaxPoolCommonSource( + xShapeRCD, fSize, stride, pad, true); +} + +export function getFragmentShaderMaxPoolSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number) { + return getFragmentShaderMaxPoolCommonSource( + xShapeRCD, fSize, stride, pad, false); +} + +function getFragmentShaderMaxPoolCommonSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number, computeMaxPositions: boolean) { + return pool_gpu.getFragmentShaderPoolCommonSource( + xShapeRCD, fSize, stride, pad, 'max', computeMaxPositions); +} + +export function maxPoolCommon( + gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture, + result: WebGLTexture, resultShapeRowCol: [number, number]) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} \ No newline at end of file diff --git a/src/math/webgl/max_pool_gpu_test.ts b/src/math/webgl/max_pool_gpu_test.ts new file mode 100644 index 0000000000..7c3dcb2817 --- /dev/null +++ b/src/math/webgl/max_pool_gpu_test.ts @@ -0,0 +1,114 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MaxPool} from '../../ops/max_pool'; +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as max_pool_gpu from './max_pool_gpu'; + +describe('max_pool_gpu', () => { + function uploadMaxPoolDownload( + a: Float32Array, aShapeRowColDepth: [number, number, number], + fieldSize: number, stride: number, zeroPad: number): Float32Array { + const aTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + aShapeRowColDepth, fieldSize, aShapeRowColDepth[2], stride, + zeroPad); + + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = max_pool_gpu.getFragmentShaderMaxPoolSource( + aShapeRowColDepth, fieldSize, stride, zeroPad); + const program = gpgpu.createProgram(shaderSource); + + const aTex = gpgpu.createMatrixTexture(aTexShapeRC[0], aTexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(aTex, aTexShapeRC[0], aTexShapeRC[1], a); + + max_pool_gpu.maxPoolCommon( + gpgpu, program, aTex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + function compareToCPU( + xShape: [number, number, number], fSize: number, stride: number, + pad: number) { + const x = NDArray.randNormal(xShape); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = mathCPU.maxPool(x, fSize, stride, pad); + const yGPU = + uploadMaxPoolDownload(x.getValues(), x.shape, fSize, stride, pad); + + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const depth = 1; + const dyShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(dyShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=1,f=3,s=2,p=1', () => { + const depth = 1; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=4,f=2,s=1,p=0', () => { + const depth = 4; + const inputShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=3,f=3,s=3,p=1', () => { + const depth = 3; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); +}); diff --git a/src/math/webgl/max_pool_positions_gpu_test.ts b/src/math/webgl/max_pool_positions_gpu_test.ts new file mode 100644 index 0000000000..86f3a8a390 --- /dev/null +++ b/src/math/webgl/max_pool_positions_gpu_test.ts @@ -0,0 +1,110 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as max_pool_gpu from './max_pool_gpu'; + +describe('max_pool_position', () => { + function uploadMaxPoolPositionDownload( + x: Float32Array, xShapeRowColDepth: [number, number, number], + fieldSize: number, stride: number, pad: number): Float32Array { + const xTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(xShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + xShapeRowColDepth, fieldSize, xShapeRowColDepth[2], stride, pad); + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = max_pool_gpu.getFragmentShaderMaxPoolPositionsSource( + xShapeRowColDepth, fieldSize, stride, pad); + const program = gpgpu.createProgram(shaderSource); + + const xTex = gpgpu.createMatrixTexture(xTexShapeRC[0], xTexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(xTex, xTexShapeRC[0], xTexShapeRC[1], x); + + max_pool_gpu.maxPoolCommon( + gpgpu, program, xTex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(xTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + function compareToCPU( + xShape: [number, number, number], fSize: number, stride: number, + pad: number) { + const x = NDArray.randNormal(xShape); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = mathCPU.maxPoolPositions(x, fSize, stride, pad); + const yGPU = uploadMaxPoolPositionDownload( + x.getValues(), x.shape, fSize, stride, pad); + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const depth = 1; + const dyShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const pad = 0; + compareToCPU(dyShape, fSize, stride, pad); + }); + + it('matches CPU on random input, d=1,f=3,s=2,p=1', () => { + const depth = 1; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 2; + const pad = 1; + compareToCPU(inputShape, fSize, stride, pad); + }); + + it('matches CPU on random input, d=4,f=2,s=1,p=0', () => { + const depth = 4; + const inputShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const pad = 0; + compareToCPU(inputShape, fSize, stride, pad); + }); + + it('matches CPU on random input, d=3,f=3,s=3,p=1', () => { + const depth = 3; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 3; + const pad = 1; + compareToCPU(inputShape, fSize, stride, pad); + }); +}); diff --git a/src/math/webgl/min_pool_gpu.ts b/src/math/webgl/min_pool_gpu.ts new file mode 100644 index 0000000000..f3b8888356 --- /dev/null +++ b/src/math/webgl/min_pool_gpu.ts @@ -0,0 +1,30 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as pool_gpu from './pool_gpu'; + +export function getFragmentShaderMinPoolSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number) { + return pool_gpu.getFragmentShaderPoolCommonSource( + xShapeRCD, fSize, stride, pad, 'min', false); +} + +export function minPool( + gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture, + result: WebGLTexture, resultShapeRowCol: [number, number]) { + pool_gpu.poolCommon(gpgpu, program, x, result, resultShapeRowCol); +} \ No newline at end of file diff --git a/src/math/webgl/min_pool_gpu_test.ts b/src/math/webgl/min_pool_gpu_test.ts new file mode 100644 index 0000000000..1911c649a4 --- /dev/null +++ b/src/math/webgl/min_pool_gpu_test.ts @@ -0,0 +1,112 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as min_pool_gpu from './min_pool_gpu'; + +describe('min_pool_gpu', () => { + function uploadMinPoolDownload( + a: Float32Array, aShapeRowColDepth: [number, number, number], + fieldSize: number, stride: number, zeroPad: number): Float32Array { + const aTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = + conv_util.computeOutputShape3D( + aShapeRowColDepth, fieldSize, aShapeRowColDepth[2], stride, + zeroPad); + + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = min_pool_gpu.getFragmentShaderMinPoolSource( + aShapeRowColDepth, fieldSize, stride, zeroPad); + const program = gpgpu.createProgram(shaderSource); + + const aTex = gpgpu.createMatrixTexture(aTexShapeRC[0], aTexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(aTex, aTexShapeRC[0], aTexShapeRC[1], a); + + min_pool_gpu.minPool(gpgpu, program, aTex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + function compareToCPU( + xShape: [number, number, number], fSize: number, stride: number, + pad: number) { + const x = NDArray.randNormal(xShape); + + const mathCPU = new NDArrayMathCPU(); + const yCPU = mathCPU.minPool(x, fSize, stride, pad); + const yGPU = + uploadMinPoolDownload(x.getValues(), x.shape, fSize, stride, pad); + + test_util.expectArraysClose(yGPU, yCPU.getValues(), 1e-5); + } + + it('matches CPU on random input, d1=1,d2=1,f=2,s=1,p=0', () => { + const depth = 1; + const dyShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(dyShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=1,f=3,s=2,p=1', () => { + const depth = 1; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 2; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=4,f=2,s=1,p=0', () => { + const depth = 4; + const inputShape: [number, number, number] = [8, 8, depth]; + const fSize = 2; + const stride = 1; + const zeroPad = 0; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); + + it('matches CPU on random input, d=3,f=3,s=3,p=1', () => { + const depth = 3; + const inputShape: [number, number, number] = [7, 7, depth]; + const fSize = 3; + const stride = 3; + const zeroPad = 1; + compareToCPU(inputShape, fSize, stride, zeroPad); + }); +}); \ No newline at end of file diff --git a/src/math/webgl/minmax_gpu.ts b/src/math/webgl/minmax_gpu.ts new file mode 100644 index 0000000000..69c9a57f94 --- /dev/null +++ b/src/math/webgl/minmax_gpu.ts @@ -0,0 +1,66 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import {IS_NAN_SHADER_FUNC} from './webgl_util'; + +function getFragmentShaderSource( + rows: number, columns: number, compOp: string): string { + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 outputColumnRow; + + const vec2 aDimCR = vec2(${columns}.0, ${rows}.0); + const vec2 halfCR = vec2(0.5, 0.5); + + ${IS_NAN_SHADER_FUNC} + + void main() { + float value = texture2D(matrixA, halfCR / aDimCR).r; + for (float r = 0.0; r < aDimCR.y; r += 1.0) { + for (float c = 0.0; c < aDimCR.x; c += 1.0) { + vec2 cr = vec2(c, r); + vec2 uv = (cr + halfCR) / aDimCR; + float candidate = texture2D(matrixA, uv).r; + if (isNaN(candidate)) { + gl_FragColor = vec4(candidate, 0, 0, 0); + return; + } + value = ${compOp}(value, candidate); + } + } + gl_FragColor = vec4(value, 0, 0, 0); + }`; +} + +export function getMinFragmentShaderSource( + rows: number, columns: number): string { + return getFragmentShaderSource(rows, columns, 'min'); +} + +export function getMaxFragmentShaderSource( + rows: number, columns: number): string { + return getFragmentShaderSource(rows, columns, 'max'); +} + +export function minMax( + gpgpu: GPGPUContext, minMaxProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(minMaxProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/minmax_gpu_test.ts b/src/math/webgl/minmax_gpu_test.ts new file mode 100644 index 0000000000..c9f05cee2c --- /dev/null +++ b/src/math/webgl/minmax_gpu_test.ts @@ -0,0 +1,103 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as minmax_gpu from './minmax_gpu'; + +function uploadMinMaxDownloadDriver( + a: Float32Array, rows: number, columns: number, + fragmentShaderSource: string): Float32Array { + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSource); + const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + minmax_gpu.minMax(gpgpu, program, aTexture, rows, columns, resultTexture); + const result = new Float32Array(4); + gpgpu.gl.readPixels(0, 0, 1, 1, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, result); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} + +function uploadMinDownload( + a: Float32Array, rows: number, columns: number): number { + const src = minmax_gpu.getMinFragmentShaderSource(rows, columns); + const result = uploadMinMaxDownloadDriver(a, rows, columns, src); + return result[0]; +} + +function uploadMaxDownload( + a: Float32Array, rows: number, columns: number): number { + const src = minmax_gpu.getMaxFragmentShaderSource(rows, columns); + const result = uploadMinMaxDownloadDriver(a, rows, columns, src); + return result[0]; +} + +describe('minmax_gpu min', () => { + it('returns the only value in a 1x1 input matrix', () => { + const a = new Float32Array([3.141]); + const minValue = uploadMinDownload(a, 1, 1); + expect(minValue).toEqual(a[0]); + }); + + it('returns min value from the first cell of a 2x1', () => { + const a = new Float32Array([-100, 100]); + const minValue = uploadMinDownload(a, 2, 1); + expect(minValue).toEqual(a[0]); + }); + + it('returns min value from the second cell of a 2x1', () => { + const a = new Float32Array([100, -1.234]); + const minValue = uploadMinDownload(a, 2, 1); + expect(minValue).toEqual(a[1]); + }); + + it('finds the min value of a large array', () => { + const a = new Float32Array(1024 * 1024); + a[a.length - 91] = -0.1; + const minValue = uploadMinDownload(a, 1024, 1024); + expect(minValue).toBeCloseTo(-0.1); + }); +}); + +describe('minmax_gpu max', () => { + it('returns the only value in a 1x1 input matrix', () => { + const a = new Float32Array([3.141]); + const maxValue = uploadMaxDownload(a, 1, 1); + expect(maxValue).toEqual(a[0]); + }); + + it('returns max value from the first cell of a 2x1', () => { + const a = new Float32Array([100, -100]); + const maxValue = uploadMaxDownload(a, 2, 1); + expect(maxValue).toEqual(a[0]); + }); + + it('returns max value from the second cell of a 2x1', () => { + const a = new Float32Array([-1.234, 100]); + const maxValue = uploadMaxDownload(a, 2, 1); + expect(maxValue).toEqual(a[1]); + }); + + it('finds the max value of a large array', () => { + const a = new Float32Array(1024 * 1024); + a[a.length - 91] = 0.1; + const maxValue = uploadMaxDownload(a, 1024, 1024); + expect(maxValue).toBeCloseTo(0.1); + }); +}); diff --git a/src/math/webgl/mulbcast_gpu.ts b/src/math/webgl/mulbcast_gpu.ts new file mode 100644 index 0000000000..8780720d0d --- /dev/null +++ b/src/math/webgl/mulbcast_gpu.ts @@ -0,0 +1,90 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + aNumRows: number, aNumCols: number, bNumRows: number, bNumCols: number, + resultNumRows: number, resultNumCols: number): string { + return ` + precision highp float; + uniform sampler2D matrixA; + uniform sampler2D matrixB; + varying vec2 resultUV; + + const vec2 aDimCR = vec2(${aNumCols}.0, ${aNumRows}.0); + const vec2 bDimCR = vec2(${bNumCols}.0, ${bNumRows}.0); + const vec2 resultDimCR = vec2(${resultNumCols}.0, ${resultNumRows}.0); + const vec4 halfCR = vec4(0.5, 0.5, 0.5, 0.5); + + void main() { + vec2 resultCR = floor(resultUV * resultDimCR); + vec4 resultCRBroadcast = vec4(resultCR, resultCR); + vec4 abDimsCR = vec4(aDimCR, bDimCR); + vec4 abCR = mod(resultCRBroadcast, abDimsCR); + vec4 abCRCenters = abCR + halfCR; + vec4 abUV = abCRCenters / abDimsCR; + vec4 a = texture2D(matrixA, abUV.rg); + vec4 b = texture2D(matrixB, abUV.ba); + float product = a.r * b.r; + gl_FragColor = vec4(product, 0, 0, 0); + }`; +} + +export function multiplyBroadcast( + gpgpu: GPGPUContext, multiplyBroadcastProgram: WebGLProgram, + a: WebGLTexture, aNumRows: number, aNumCols: number, b: WebGLTexture, + bNumRows: number, bNumCols: number, result: WebGLTexture, + resultNumRows: number, resultNumCols: number) { + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(multiplyBroadcastProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} + +export function uploadMultiplyBroadcastDownload( + a: Float32Array, aNumRows: number, aNumCols: number, b: Float32Array, + bNumRows: number, bNumCols: number): Float32Array { + const resultNumRows = Math.max(aNumRows, bNumRows); + const resultNumCols = Math.max(aNumCols, bNumCols); + + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = gpgpu.createProgram(getFragmentShaderSource( + aNumRows, aNumCols, bNumRows, bNumCols, resultNumRows, resultNumCols)); + + const aTexture: WebGLTexture = gpgpu.createMatrixTexture(aNumRows, aNumCols); + const bTexture: WebGLTexture = gpgpu.createMatrixTexture(bNumRows, bNumCols); + const resultTexture: WebGLTexture = + gpgpu.createMatrixTexture(resultNumRows, resultNumCols); + + gpgpu.uploadMatrixToTexture(aTexture, aNumRows, aNumCols, a); + gpgpu.uploadMatrixToTexture(bTexture, bNumRows, bNumCols, b); + + multiplyBroadcast( + gpgpu, program, aTexture, aNumRows, aNumCols, bTexture, bNumRows, + bNumCols, resultTexture, resultNumRows, resultNumCols); + + const result = gpgpu.downloadMatrixFromTexture( + resultTexture, resultNumRows, resultNumCols); + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return result; +} diff --git a/src/math/webgl/mulbcast_gpu_test.ts b/src/math/webgl/mulbcast_gpu_test.ts new file mode 100644 index 0000000000..e32c50179e --- /dev/null +++ b/src/math/webgl/mulbcast_gpu_test.ts @@ -0,0 +1,140 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as mulbcast_gpu from './mulbcast_gpu'; + +export function cpuMultiplyBroadcast( + a: Float32Array, aNumRows: number, aNumCols: number, b: Float32Array, + bNumRows: number, bNumCols: number): Float32Array { + const resultNumRows = Math.max(aNumRows, bNumRows); + const resultNumCols = Math.max(aNumCols, bNumCols); + const result = new Float32Array(resultNumRows * resultNumCols); + let dst = 0; + for (let r = 0; r < resultNumRows; ++r) { + for (let c = 0; c < resultNumCols; ++c) { + const ai = ((r % aNumRows) * aNumCols) + (c % aNumCols); + const bi = ((r % bNumRows) * bNumCols) + (c % bNumCols); + result[dst] = a[ai] * b[bi]; + ++dst; + } + } + return result; +} + +describe('mulbcast_gpu', () => { + it('returns a matrix dimensions [max(aRows, bRows), max(aCols, bCols)]', + () => { + const a = new Float32Array(13 * 100); + const b = new Float32Array(100 * 99); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 1, 100, b, 100, 1); + expect(result.length).toEqual(100 * 100); + }); + + it('returns [0] when A is [0], A and B same size', () => { + const a = new Float32Array(16 * 16); + const b = test_util.randomArrayInRange(16 * 16, -10, 10); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 16, 16, b, 16, 16); + test_util.expectArraysClose(a, result, 0.00001); + }); + + it('returns [0] when B is [0], A and B same size', () => { + const a = test_util.randomArrayInRange(16 * 16, -10, 10); + const b = new Float32Array(16 * 16); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 16, 16, b, 16, 16); + test_util.expectArraysClose(b, result, 0.00001); + }); + + it('returns A when B is [1] and matrices have the same size', () => { + const a = new Float32Array(16 * 16); + a.fill(1); + const b = test_util.randomArrayInRange(16 * 16, -10, 10); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 16, 16, b, 16, 16); + test_util.expectArraysClose(result, b, 0.00001); + }); + + it('returns B when A is [1] and matrices have the same size', () => { + const a = test_util.randomArrayInRange(16 * 16, -10, 10); + const b = new Float32Array(16 * 16); + b.fill(1); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 16, 16, b, 16, 16); + test_util.expectArraysClose(result, a, 0.00001); + }); + + it('returns B when A is [1] and A is narrower than B', () => { + const a = new Float32Array(16 * 8); + a.fill(1); + const b = test_util.randomArrayInRange(16 * 16, -10, 10); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 16, 8, b, 16, 16); + test_util.expectArraysClose(result, b, 0.00001); + }); + + it('returns B when A is [1] and A is shorter than B', () => { + const a = new Float32Array(8 * 16); + a.fill(1); + const b = test_util.randomArrayInRange(16 * 16, -10, 10); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 8, 16, b, 16, 16); + test_util.expectArraysClose(result, b, 0.00001); + }); + + it('returns B when A is [1] and A is smaller than B', () => { + const a = new Float32Array(7 * 6); + a.fill(1); + const b = test_util.randomArrayInRange(18 * 21, -1, 1); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 7, 6, b, 18, 21); + test_util.expectArraysClose(result, b, 0.00001); + }); + + it('broadcasts a smaller A [2x2] across B [4x4]', () => { + const a = new Float32Array([1, 0, 1, 0]); + const b = new Float32Array(4 * 4); + for (let i = 0; i < b.length; ++i) { + b[i] = i + 1; + } + const expected = + new Float32Array([1, 0, 3, 0, 5, 0, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0]); + const gpuResult = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 2, 2, b, 4, 4); + const cpuResult = cpuMultiplyBroadcast(a, 2, 2, b, 4, 4); + test_util.expectArraysClose(cpuResult, expected, 0.0001); + test_util.expectArraysClose(gpuResult, expected, 0.0001); + }); + + it('broadcasts a non-square A [3x5] across a larger B [16x16]', () => { + const a = test_util.randomArrayInRange(3 * 5, -1, 1); + const b = test_util.randomArrayInRange(16 * 16, -1, 1); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 3, 5, b, 16, 16); + test_util.expectArraysClose( + result, cpuMultiplyBroadcast(a, 3, 5, b, 16, 16), 0.0001); + }); + + it('broadcasts a non-square A across a larger non-square B', () => { + const a = test_util.randomArrayInRange(37 * 63, -1, 1); + const b = test_util.randomArrayInRange(128 * 150, -1, 1); + const result = + mulbcast_gpu.uploadMultiplyBroadcastDownload(a, 37, 63, b, 128, 150); + test_util.expectArraysClose( + result, cpuMultiplyBroadcast(a, 37, 63, b, 128, 150), 0.0001); + }); +}); diff --git a/src/math/webgl/mulmat_gpu.ts b/src/math/webgl/mulmat_gpu.ts new file mode 100644 index 0000000000..309b8501f8 --- /dev/null +++ b/src/math/webgl/mulmat_gpu.ts @@ -0,0 +1,62 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MatrixOrientation} from '../math'; +import {Array2D} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as shader_compiler from './shader_compiler'; + +export function getFragmentShader( + a: Array2D, b: Array2D, out: Array2D, aOrientation: MatrixOrientation, + bOrientation: MatrixOrientation): string { + const sharedDim = + (aOrientation === MatrixOrientation.REGULAR ? a.shape[1] : a.shape[0]); + const aSnippet = + (aOrientation === MatrixOrientation.REGULAR) ? 'aRow, i' : 'i, aRow'; + const bSnippet = + (bOrientation === MatrixOrientation.REGULAR) ? 'i, bCol' : 'bCol, i'; + + const inputs = [{name: 'matrixA', array: a}, {name: 'matrixB', array: b}]; + const userCode = ` + const float sharedDim = ${sharedDim}.0; + + float dotARowBCol(float aRow, float bCol) { + float result = 0.0; + for (float i = 0.0; i < sharedDim; i += 1.0) { + float a = getMatrixA(${aSnippet}); + float b = getMatrixB(${bSnippet}); + result += (a * b); + } + return result; + } + + void main() { + vec2 resRC = getOutputCoords(); + setOutput(dotARowBCol(resRC.x, resRC.y)); + } + `; + return shader_compiler.makeShader(inputs, out, userCode); +} + +export function multiplyMatrix( + gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture, + b: WebGLTexture, result: WebGLTexture, outTexShape: [number, number]) { + gpgpu.setOutputMatrixTexture(result, outTexShape[0], outTexShape[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/mulmat_gpu_test.ts b/src/math/webgl/mulmat_gpu_test.ts new file mode 100644 index 0000000000..6ba5a5ed46 --- /dev/null +++ b/src/math/webgl/mulmat_gpu_test.ts @@ -0,0 +1,382 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import {MatrixOrientation} from '../math'; +import {Array2D} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as mulmat_gpu from './mulmat_gpu'; + +describe('mulmat_gpu (1x1 * 1x1)', () => { + it('returns a 1x1 matrix', () => { + const a = new Float32Array([0]); + const b = new Float32Array([0]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result.length).toEqual(1); + }); + + it('returns [0] when multiplying [0] by [0]', () => { + const a = new Float32Array([0]); + const b = new Float32Array([0]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toEqual(0); + }); + + it('returns [1] when multiplying [1] by [1]', () => { + const a = new Float32Array([1]); + const b = new Float32Array([1]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toEqual(1); + }); + + it('returns [-1] when multiplying [1] by [-1]', () => { + const a = new Float32Array([1]); + const b = new Float32Array([-1]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toEqual(-1); + }); + + it('returns [4.08] when multiplying [1.2] by [3.4]', () => { + const a = new Float32Array([1.2]); + const b = new Float32Array([3.4]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toBeCloseTo(4.08); + }); + + it('returns [356000] when multiplying [356] by [1000]', () => { + const a = new Float32Array([356]); + const b = new Float32Array([1000]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toEqual(356000); + }); + + it('returns [-31415926] when multiplying [-3.1415926] by [10000000]', () => { + const a = new Float32Array([-3.1415926]); + const b = new Float32Array([10000000]); + const result = uploadMultiplyMatrixDownload(a, 1, 1, b, 1, 1); + expect(result[0]).toEqual(-31415926); + }); +}); + +describe('mulmat_gpu (dot product)', () => { + it('returns a 1x1 matrix', () => { + const a = new Float32Array(5); + const b = new Float32Array(5); + const result = uploadMultiplyMatrixDownload(a, 1, a.length, b, b.length, 1); + expect(result.length).toEqual(1); + }); + + it('returns zero when one vector is all zeroes', () => { + const a = new Float32Array(5); + const b = new Float32Array([1, 2, 3, 4, 5]); + const result = uploadMultiplyMatrixDownload(a, 1, a.length, b, b.length, 1); + expect(result[0]).toEqual(0); + }); + + it('returns the sum of b when a is all ones', () => { + const a = new Float32Array([1, 1, 1, 1, 1]); + const b = new Float32Array([0, 1, 2, 3, 100]); + const result = uploadMultiplyMatrixDownload(a, 1, a.length, b, b.length, 1); + expect(result[0]).toEqual(106); + }); + + it('computes the dot product of a and b', () => { + const a = new Float32Array([10, 20, 30, 40, 50]); + const b = new Float32Array([0.5, 1.1, 12.4, 32.5, -123.98]); + const result = uploadMultiplyMatrixDownload(a, 1, a.length, b, b.length, 1); + const expected = test_util.cpuDotProduct(a, b); + expect(result[0]).toBeCloseTo(expected); + }); + + it('computes a dot product on very large vectors', () => { + const a: Float32Array = test_util.randomArrayInRange(2048, -1, 1); + const b: Float32Array = test_util.randomArrayInRange(2048, -1, 1); + const result = uploadMultiplyMatrixDownload(a, 1, a.length, b, b.length, 1); + const expected = test_util.cpuDotProduct(a, b); + expect(result[0]).toBeCloseTo(expected); + }); +}); + +function cpuMul2x2(a: Float32Array, b: Float32Array): Float32Array { + if (a.length !== 4 || b.length !== 4) { + throw new Error('a and b must have 4 elements.'); + } + /* + a = [0 1 b = [0 1 + 2 3] 2 3] + a[0] = [a0 a1] dot [b0 b2] + a[1] = [a0 a1] dot [b1 b3] + a[2] = [a2 a3] dot [b0 b2] + a[3] = [a2 a3] dot [b1 b3] + */ + const result = new Float32Array(4); + result[0] = (a[0] * b[0]) + (a[1] * b[2]); + result[1] = (a[0] * b[1]) + (a[1] * b[3]); + result[2] = (a[2] * b[0]) + (a[3] * b[2]); + result[3] = (a[2] * b[1]) + (a[3] * b[3]); + return result; +} + +describe('mulmat_gpu (2x2 * 2x2)', () => { + it('returns a 2x2 matrix', () => { + const a = new Float32Array([0, 0, 0, 0]); + const b = new Float32Array([0, 0, 0, 0]); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result.length).toEqual(4); + }); + + it('returns the identity when multiplying two identity matrices', () => { + const a = test_util.makeIdentity(2); + const b = test_util.makeIdentity(2); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(cpuMul2x2(a, b)); + }); + + it('returns [0] when A is [0]', () => { + const a = new Float32Array([0, 0, 0, 0]); + const b = new Float32Array([1, 2, 3, 4]); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(a); + }); + + it('returns [0] when B is [0]', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array(4); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(b); + }); + + it('returns B when A is identity', () => { + const a = test_util.makeIdentity(2); + const b = new Float32Array([11, -22, 33.333, -44.44444]); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(b); + }); + + it('returns A when B is identity', () => { + const a = new Float32Array([11, -22, 33.333, -44.44444]); + const b = test_util.makeIdentity(2); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(a); + }); + + it('returns the product of A and B when non-identity', () => { + const a = new Float32Array([10000.02, -1.2, 3.14159, -2345.1234]); + const b = new Float32Array([-23.45, 0.01234, 100, 2.5]); + const result = uploadMultiplyMatrixDownload(a, 2, 2, b, 2, 2); + expect(result).toEqual(cpuMul2x2(a, b)); + }); +}); + +describe('mulmat_gpu (different shapes)', () => { + it('returns a 4x1 when multiplying a 4x4 with a 4x1', () => { + const a = new Float32Array(16); + const b = new Float32Array(4); + const result = uploadMultiplyMatrixDownload(a, 4, 4, b, 4, 1); + expect(result.length).toEqual(4); + }); + + it('returns B (4x1) when A (4x4) is I', () => { + const a = test_util.makeIdentity(4); + const b = new Float32Array([1, 2, 3, 4]); + const result = uploadMultiplyMatrixDownload(a, 4, 4, b, 4, 1); + expect(result).toEqual(b); + }); + + it('multiplies a 4x1 by a non-identity 4x4', () => { + const a = new Float32Array( + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + const b = new Float32Array([1, 2, 3, 4]); + const result = uploadMultiplyMatrixDownload(a, 4, 4, b, 4, 1); + expect(result).toEqual(test_util.cpuMultiplyMatrix(a, 4, 4, b, 4, 1)); + }); + + it('returns a 2x3 when multiplying a 2x4 by a 4x3', () => { + const a = new Float32Array(8); + const b = new Float32Array(12); + const result = uploadMultiplyMatrixDownload(a, 2, 4, b, 4, 3); + expect(result.length).toEqual(6); + }); + + it('multiplies A (2x4) by B(4x3)', () => { + const a = new Float32Array([0.1, 3.2, -4.5, 11.78, -0.234, -2.999, 7, 9]); + const b = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const result = uploadMultiplyMatrixDownload(a, 2, 4, b, 4, 3); + const expected = test_util.cpuMultiplyMatrix(a, 2, 4, b, 4, 3); + test_util.expectArraysClose(result, expected, 0.00001); + }); +}); + +describe('mulmat_gpu (large matrices)', () => { + it('returns 128x128 when multiplying 2 128x128s', () => { + const a = new Float32Array(128 * 128); + const b = new Float32Array(128 * 128); + const result = uploadMultiplyMatrixDownload(a, 128, 128, b, 128, 128); + expect(result.length).toEqual(128 * 128); + }); + + it('multiplies 2 128x128s', () => { + const a = test_util.randomArrayInRange(128 * 128, -1, 1); + const b = test_util.randomArrayInRange(128 * 128, -1, 1); + const result = uploadMultiplyMatrixDownload(a, 128, 128, b, 128, 128); + const expected = test_util.cpuMultiplyMatrix(a, 128, 128, b, 128, 128); + test_util.expectArraysClose(result, expected, 0.001); + }); +}); + +describe('mulmat_gpu (multiple matrices)', () => { + it('4x2 * 2x12 * 12x1 === 4x1', () => { + const aData = new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]); + const bData = new Float32Array([ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 + ]); + const cData = new Float32Array([ + -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1, -1.2 + ]); + + const gpgpu = new GPGPUContext(); + + const aShape: [number, number] = [4, 2]; + const bShape: [number, number] = [2, 12]; + const abShape: [number, number] = [aShape[0], bShape[1]]; + const cShape: [number, number] = [12, 1]; + const rShape: [number, number] = [aShape[0], cShape[1]]; + + const a: WebGLTexture = gpgpu.createMatrixTexture(aShape[0], aShape[1]); + const b: WebGLTexture = gpgpu.createMatrixTexture(bShape[0], bShape[1]); + const ab: WebGLTexture = gpgpu.createMatrixTexture(abShape[0], abShape[1]); + const c: WebGLTexture = gpgpu.createMatrixTexture(cShape[0], cShape[1]); + const r: WebGLTexture = gpgpu.createMatrixTexture(rShape[0], rShape[1]); + + const aArr = new Array2D(aShape, {texture: a, textureShapeRC: aShape}); + const bArr = new Array2D(bShape, {texture: b, textureShapeRC: bShape}); + const abArr = new Array2D(abShape, {texture: ab, textureShapeRC: abShape}); + const cArr = new Array2D(cShape, {texture: c, textureShapeRC: cShape}); + const rArr = new Array2D(rShape, {texture: r, textureShapeRC: rShape}); + + const axbProgram = gpgpu.createProgram(mulmat_gpu.getFragmentShader( + aArr, bArr, cArr, MatrixOrientation.REGULAR, + MatrixOrientation.REGULAR)); + const abxcProgram = gpgpu.createProgram(mulmat_gpu.getFragmentShader( + abArr, cArr, rArr, MatrixOrientation.REGULAR, + MatrixOrientation.REGULAR)); + + gpgpu.uploadMatrixToTexture(a, aShape[0], aShape[1], aData); + gpgpu.uploadMatrixToTexture(b, bShape[0], bShape[1], bData); + gpgpu.uploadMatrixToTexture(c, cShape[0], cShape[1], cData); + + mulmat_gpu.multiplyMatrix( + gpgpu, axbProgram, a, b, ab, [abShape[0], abShape[1]]); + mulmat_gpu.multiplyMatrix( + gpgpu, abxcProgram, ab, c, r, [rShape[0], rShape[1]]); + + const result = gpgpu.downloadMatrixFromTexture(r, rShape[0], rShape[1]); + const expected = test_util.cpuMultiplyMatrix( + test_util.cpuMultiplyMatrix(aData, 4, 2, bData, 2, 12), 4, 12, cData, + 12, 1); + test_util.expectArraysClose(result, expected, 0.0001); + + gpgpu.deleteMatrixTexture(a); + gpgpu.deleteMatrixTexture(b); + gpgpu.deleteMatrixTexture(ab); + gpgpu.deleteMatrixTexture(c); + gpgpu.deleteMatrixTexture(r); + gpgpu.deleteProgram(axbProgram); + gpgpu.deleteProgram(abxcProgram); + gpgpu.dispose(); + }); +}); + +describe('mulmat_gpu (transposed versions)', () => { + it('A * B^t', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = uploadMultiplyMatrixDownload( + a, 2, 3, b, 2, 3, MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([7, 10, 16, 31]); + expect(c).toEqual(expected); + }); + + it('A^t * B', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = uploadMultiplyMatrixDownload( + a, 2, 3, b, 2, 3, MatrixOrientation.TRANSPOSED, + MatrixOrientation.REGULAR); + const expected = new Float32Array([17, 12, 2, 22, 15, 4, 27, 18, 6]); + expect(c).toEqual(expected); + }); + + it('A^t * B^t', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = uploadMultiplyMatrixDownload( + a, 3, 2, b, 2, 3, MatrixOrientation.TRANSPOSED, + MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([11, 13, 14, 20]); + expect(c).toEqual(expected); + }); +}); + +export function uploadMultiplyMatrixDownload( + a: Float32Array, aNumRows: number, aNumCols: number, b: Float32Array, + bNumRows: number, bNumCols: number, + aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const outNumRows = + (aOrientation === MatrixOrientation.REGULAR) ? aNumRows : aNumCols; + const outNumCols = + (bOrientation === MatrixOrientation.REGULAR) ? bNumCols : bNumRows; + const gpgpu = new GPGPUContext(); + const aShape: [number, number] = [aNumRows, aNumCols]; + const bShape: [number, number] = [bNumRows, bNumCols]; + const outShape: [number, number] = [outNumRows, outNumCols]; + + const aTexture = gpgpu.createMatrixTexture(aNumRows, aNumCols); + const aArr = new Array2D( + aShape, {texture: aTexture, textureShapeRC: [aNumRows, aNumCols]}); + const bTexture = gpgpu.createMatrixTexture(bNumRows, bNumCols); + const bArr = new Array2D( + bShape, {texture: bTexture, textureShapeRC: [bNumRows, bNumCols]}); + const resultTexture: WebGLTexture = + gpgpu.createMatrixTexture(outNumRows, outNumCols); + const resArr = + new Array2D(outShape, {texture: resultTexture, textureShapeRC: outShape}); + const shader = mulmat_gpu.getFragmentShader( + aArr, bArr, resArr, aOrientation, bOrientation); + const program: WebGLProgram = gpgpu.createProgram(shader); + + + gpgpu.uploadMatrixToTexture(aTexture, aNumRows, aNumCols, a); + gpgpu.uploadMatrixToTexture(bTexture, bNumRows, bNumCols, b); + + mulmat_gpu.multiplyMatrix( + gpgpu, program, aTexture, bTexture, resultTexture, + resArr.getTextureShapeRC()); + + const result = + gpgpu.downloadMatrixFromTexture(resultTexture, outNumRows, outNumCols); + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return result; +} diff --git a/src/math/webgl/mulmat_packed_gpu.ts b/src/math/webgl/mulmat_packed_gpu.ts new file mode 100644 index 0000000000..a025f3a6b0 --- /dev/null +++ b/src/math/webgl/mulmat_packed_gpu.ts @@ -0,0 +1,130 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {MatrixOrientation} from '../math'; + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource( + sharedDimension: number, aOrientation: MatrixOrientation, + bOrientation: MatrixOrientation): string { + /* + A = [0 1 B = [0 1 out = [A0*B0+A1*B2 A0*B1+A1*B3 + 2 3] 2 3] A2*B0+A1*B2 A2*B1+Aw*B3] + out.0 = A0 * B0 + A1 * B2 + out.1 = A0 * B1 + A1 * B3 + out.2 = A2 * B0 + A3 * B2 + out.3 = A2 * B1 + A3 * B3 + + A*B = A.xxzz * B.xyxy + A.yyww * B.zwzw + A^t*B = A.xxyy * B.xyxy + A.zzww * B.zwzw + A*B^t = A.xxzz * B.xzxz + A.yyww * B.ywyw + A^t*B^t = A.xxyy * B.xzxz + A.zzww * B.ywyw + */ + const sharedDimensionPacked = Math.ceil(sharedDimension / 2); + const aSample = (aOrientation === MatrixOrientation.REGULAR) ? + 'center, resultUV.t' : + 'resultUV.t, center'; + const bSample = (bOrientation === MatrixOrientation.REGULAR) ? + 'resultUV.s, center' : + 'center, resultUV.s'; + const aSwizzle: [string, string] = + (aOrientation === MatrixOrientation.REGULAR) ? ['a.xxzz', 'a.yyww'] : + ['a.xxyy', 'a.zzww']; + const bSwizzle: [string, string] = + (bOrientation === MatrixOrientation.REGULAR) ? ['b.xyxy', 'b.zwzw'] : + ['b.xzxz', 'b.ywyw']; + return ` + precision highp float; + uniform sampler2D matrixA; + uniform sampler2D matrixB; + varying vec2 resultUV; + + const float sharedDimension = ${sharedDimensionPacked}.0; + + vec4 dot2x2ARowBCol() { + vec4 result = vec4(0, 0, 0, 0); + for (float i = 0.0; i < sharedDimension; i += 1.0) { + float center = (i + 0.5) / sharedDimension; + vec4 a = texture2D(matrixA, vec2(${aSample})); + vec4 b = texture2D(matrixB, vec2(${bSample})); + result += + (${aSwizzle[0]} * ${bSwizzle[0]}) + (${aSwizzle[1]} * ${bSwizzle[1]}); + } + return result; + } + + void main() { + gl_FragColor = dot2x2ARowBCol(); + }`; +} + +export function multiplyMatrixPacked( + gpgpu: GPGPUContext, multiplyProgram: WebGLProgram, a: WebGLTexture, + b: WebGLTexture, result: WebGLTexture, + resultShapeRowCol: [number, number]) { + gpgpu.setOutputPackedMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(multiplyProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.setInputMatrixTexture(b, 'matrixB', 1); + gpgpu.executeProgram(); +} + +export function uploadMultiplyMatrixPackedDownload( + a: Float32Array, aShapeRowCol: [number, number], b: Float32Array, + bShapeRowCol: [number, number], aOrientation = MatrixOrientation.REGULAR, + bOrientation = MatrixOrientation.REGULAR): Float32Array { + const resultNumRows = (aOrientation === MatrixOrientation.REGULAR) ? + aShapeRowCol[0] : + aShapeRowCol[1]; + const resultNumCols = (bOrientation === MatrixOrientation.REGULAR) ? + bShapeRowCol[1] : + bShapeRowCol[0]; + const sharedDimension = (aOrientation === MatrixOrientation.REGULAR) ? + aShapeRowCol[1] : + aShapeRowCol[0]; + + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = gpgpu.createProgram( + getFragmentShaderSource(sharedDimension, aOrientation, bOrientation)); + + const aTexture: WebGLTexture = + gpgpu.createPackedMatrixTexture(aShapeRowCol[0], aShapeRowCol[1]); + const bTexture: WebGLTexture = + gpgpu.createPackedMatrixTexture(bShapeRowCol[0], bShapeRowCol[1]); + const resultTexture: WebGLTexture = + gpgpu.createPackedMatrixTexture(resultNumRows, resultNumCols); + + gpgpu.uploadMatrixToPackedTexture( + aTexture, aShapeRowCol[0], aShapeRowCol[1], a); + gpgpu.uploadMatrixToPackedTexture( + bTexture, bShapeRowCol[0], bShapeRowCol[1], b); + + multiplyMatrixPacked( + gpgpu, program, aTexture, bTexture, resultTexture, + [resultNumRows, resultNumCols]); + + const result = gpgpu.downloadMatrixFromPackedTexture( + resultTexture, resultNumRows, resultNumCols); + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(bTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + + return result; +} diff --git a/src/math/webgl/mulmat_packed_gpu_test.ts b/src/math/webgl/mulmat_packed_gpu_test.ts new file mode 100644 index 0000000000..72f4555a32 --- /dev/null +++ b/src/math/webgl/mulmat_packed_gpu_test.ts @@ -0,0 +1,404 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import {MatrixOrientation} from '../math'; + +import {GPGPUContext} from './gpgpu_context'; +import * as mulmat_packed_gpu from './mulmat_packed_gpu'; + +describe('mulmat_packed_gpu (1x1 * 1x1)', () => { + it('returns a 1x1 matrix', () => { + const a = new Float32Array([0]); + const b = new Float32Array([0]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result.length).toEqual(1); + }); + + it('returns [0] when multiplying [0] by [0]', () => { + const a = new Float32Array([0]); + const b = new Float32Array([0]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toEqual(0); + }); + + it('returns [1] when multiplying [1] by [1]', () => { + const a = new Float32Array([1]); + const b = new Float32Array([1]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toEqual(1); + }); + + it('returns [-1] when multiplying [1] by [-1]', () => { + const a = new Float32Array([1]); + const b = new Float32Array([-1]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toEqual(-1); + }); + + it('returns [4.08] when multiplying [1.2] by [3.4]', () => { + const a = new Float32Array([1.2]); + const b = new Float32Array([3.4]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toBeCloseTo(4.08); + }); + + it('returns [356000] when multiplying [356] by [1000]', () => { + const a = new Float32Array([356]); + const b = new Float32Array([1000]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toEqual(356000); + }); + + it('returns [-31415926] when multiplying [-3.1415926] by [10000000]', () => { + const a = new Float32Array([-3.1415926]); + const b = new Float32Array([10000000]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1]); + expect(result[0]).toEqual(-31415926); + }); +}); + +describe('mulmat_packed_gpu (dot product)', () => { + it('returns a 1x1 matrix', () => { + const a = new Float32Array(5); + const b = new Float32Array(5); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, a.length], b, [b.length, 1]); + expect(result.length).toEqual(1); + }); + + it('returns zero when one vector is all zeroes', () => { + const a = new Float32Array(5); + const b = new Float32Array([1, 2, 3, 4, 5]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, a.length], b, [b.length, 1]); + expect(result[0]).toEqual(0); + }); + + it('returns the sum of b when a is all ones', () => { + const a = new Float32Array([1, 1, 1, 1, 1]); + const b = new Float32Array([0, 1, 2, 3, 100]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, a.length], b, [b.length, 1]); + expect(result[0]).toEqual(106); + }); + + it('computes the dot product of a and b', () => { + const a = new Float32Array([10, 20, 30, 40, 50]); + const b = new Float32Array([0.5, 1.1, 12.4, 32.5, -123.98]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, a.length], b, [b.length, 1]); + const expected = test_util.cpuDotProduct(a, b); + expect(result[0]).toBeCloseTo(expected); + }); + + it('computes a dot product on very large vectors', () => { + const a: Float32Array = test_util.randomArrayInRange(2048, -1, 1); + const b: Float32Array = test_util.randomArrayInRange(2048, -1, 1); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, a.length], b, [b.length, 1]); + const expected = test_util.cpuDotProduct(a, b); + expect(result[0]).toBeCloseTo(expected); + }); +}); + +function cpuMul2x2(a: Float32Array, b: Float32Array): Float32Array { + if (a.length !== 4 || b.length !== 4) { + throw new Error('a and b must have 4 elements.'); + } + /* + a = [0 1 b = [0 1 + 2 3] 2 3] + a[0] = [a0 a1] dot [b0 b2] + a[1] = [a0 a1] dot [b1 b3] + a[2] = [a2 a3] dot [b0 b2] + a[3] = [a2 a3] dot [b1 b3] + */ + const result = new Float32Array(4); + result[0] = (a[0] * b[0]) + (a[1] * b[2]); + result[1] = (a[0] * b[1]) + (a[1] * b[3]); + result[2] = (a[2] * b[0]) + (a[3] * b[2]); + result[3] = (a[2] * b[1]) + (a[3] * b[3]); + return result; +} + +describe('mulmat_packed_gpu (2x2 * 2x2)', () => { + it('returns a 2x2 matrix', () => { + const a = new Float32Array([0, 0, 0, 0]); + const b = new Float32Array([0, 0, 0, 0]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result.length).toEqual(4); + }); + + it('returns the identity when multiplying two identity matrices', () => { + const a = test_util.makeIdentity(2); + const b = test_util.makeIdentity(2); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(cpuMul2x2(a, b)); + }); + + it('returns [0] when A is [0]', () => { + const a = new Float32Array([0, 0, 0, 0]); + const b = new Float32Array([1, 2, 3, 4]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(a); + }); + + it('returns [0] when B is [0]', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array(4); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(b); + }); + + it('returns B when A is identity', () => { + const a = test_util.makeIdentity(2); + const b = new Float32Array([11, -22, 33.333, -44.44444]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(b); + }); + + it('returns A when B is identity', () => { + const a = new Float32Array([11, -22, 33.333, -44.44444]); + const b = test_util.makeIdentity(2); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(a); + }); + + it('returns the product of A and B when non-identity', () => { + const a = new Float32Array([10000.02, -1.2, 3.14159, -2345.1234]); + const b = new Float32Array([-23.45, 0.01234, 100, 2.5]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2]); + expect(result).toEqual(cpuMul2x2(a, b)); + }); +}); + +describe('mulmat_packed_gpu (different shapes)', () => { + it('returns a 4x1 when multiplying a 4x4 with a 4x1', () => { + const a = new Float32Array(16); + const b = new Float32Array(4); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [4, 4], b, [4, 1]); + expect(result.length).toEqual(4); + }); + + it('returns B (4x1) when A (4x4) is I', () => { + const a = test_util.makeIdentity(4); + const b = new Float32Array([1, 2, 3, 4]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [4, 4], b, [4, 1]); + expect(result).toEqual(b); + }); + + it('4x2 * 2x2', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]); + const b = new Float32Array([9, 10, 11, 12]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [4, 2], b, [2, 2]); + const expected = test_util.cpuMultiplyMatrix(a, 4, 2, b, 2, 2); + test_util.expectArraysClose(result, expected, 0); + }); + + it('multiplies a 4x1 by a non-identity 4x4', () => { + const a = new Float32Array( + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + const b = new Float32Array([1, 2, 3, 4]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [4, 4], b, [4, 1]); + expect(result).toEqual(test_util.cpuMultiplyMatrix(a, 4, 4, b, 4, 1)); + }); + + it('returns a 2x3 when multiplying a 2x4 by a 4x3', () => { + const a = new Float32Array(8); + const b = new Float32Array(12); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 4], b, [4, 3]); + expect(result.length).toEqual(6); + }); + + it('multiplies A (2x4) by B(4x3)', () => { + const a = new Float32Array([0.1, 3.2, -4.5, 11.78, -0.234, -2.999, 7, 9]); + const b = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 4], b, [4, 3]); + const expected = test_util.cpuMultiplyMatrix(a, 2, 4, b, 4, 3); + test_util.expectArraysClose(result, expected, 0.00001); + }); +}); + +describe('mulmat_packed_gpu (large matrices)', () => { + it('returns 128x128 when multiplying 2 128x128s', () => { + const a = new Float32Array(128 * 128); + const b = new Float32Array(128 * 128); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [128, 128], b, [128, 128]); + expect(result.length).toEqual(128 * 128); + }); + + it('multiplies 2 128x128s', () => { + const a = test_util.randomArrayInRange(128 * 128, -1, 1); + const b = test_util.randomArrayInRange(128 * 128, -1, 1); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [128, 128], b, [128, 128]); + const expected = test_util.cpuMultiplyMatrix(a, 128, 128, b, 128, 128); + test_util.expectArraysClose(result, expected, 0.001); + }); +}); + +describe('mulmat_packed_gpu (multiple matrices)', () => { + it('4x2 * 2x12 * 12x1 === 4x1', () => { + const aData = new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]); + const bData = new Float32Array([ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 + ]); + const cData = new Float32Array([ + -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1, -1.2 + ]); + + const gpgpu = new GPGPUContext(); + + const axbProgram = + gpgpu.createProgram(mulmat_packed_gpu.getFragmentShaderSource( + 2, MatrixOrientation.REGULAR, MatrixOrientation.REGULAR)); + const abxcProgram = + gpgpu.createProgram(mulmat_packed_gpu.getFragmentShaderSource( + 12, MatrixOrientation.REGULAR, MatrixOrientation.REGULAR)); + + const a: WebGLTexture = gpgpu.createPackedMatrixTexture(4, 2); + const b: WebGLTexture = gpgpu.createPackedMatrixTexture(2, 12); + const ab: WebGLTexture = gpgpu.createPackedMatrixTexture(4, 12); + const c: WebGLTexture = gpgpu.createPackedMatrixTexture(12, 1); + const r: WebGLTexture = gpgpu.createPackedMatrixTexture(4, 1); + + gpgpu.uploadMatrixToPackedTexture(a, 4, 2, aData); + gpgpu.uploadMatrixToPackedTexture(b, 2, 12, bData); + gpgpu.uploadMatrixToPackedTexture(c, 12, 1, cData); + + mulmat_packed_gpu.multiplyMatrixPacked( + gpgpu, axbProgram, a, b, ab, [4, 12]); + mulmat_packed_gpu.multiplyMatrixPacked( + gpgpu, abxcProgram, ab, c, r, [4, 1]); + + const result = gpgpu.downloadMatrixFromPackedTexture(r, 4, 1); + const expected = test_util.cpuMultiplyMatrix( + test_util.cpuMultiplyMatrix(aData, 4, 2, bData, 2, 12), 4, 12, cData, + 12, 1); + test_util.expectArraysClose(result, expected, 0.0001); + + gpgpu.deleteMatrixTexture(a); + gpgpu.deleteMatrixTexture(b); + gpgpu.deleteMatrixTexture(ab); + gpgpu.deleteMatrixTexture(c); + gpgpu.deleteMatrixTexture(r); + gpgpu.deleteProgram(axbProgram); + gpgpu.deleteProgram(abxcProgram); + gpgpu.dispose(); + }); +}); + +describe('mulmat_packed_gpu A * B^t', () => { + it('1x1 * 1x1', () => { + const a = new Float32Array([2]); + const b = new Float32Array([3]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [1, 1], b, [1, 1], MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + expect(result[0]).toEqual(6); + }); + + it('2x2 * 2x2', () => { + const a = new Float32Array([1, 2, 3, 4]); + const b = new Float32Array([5, 6, 7, 8]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 2], b, [2, 2], MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + + const bt = new Float32Array([b[0], b[2], b[1], b[3]]); + const expected = test_util.cpuMultiplyMatrix(a, 2, 2, bt, 2, 2); + test_util.expectArraysClose(result, expected, 0); + }); + + it('2x4 * 4x2', () => { + /* + A = [1 2 3 4 B = [ 9 10 11 12 B^t = [ 9 13 + 5 6 7 8] 13 14 15 16] 10 14 + 11 15 + 12 16] + + A * B^t = [1*9+2*10+3*11+4*12 1*13+2*14+3*15+4*16 + 5*9+6*10+7*11+8*12 5*13+6*14+7*15+8*16] + + = [110 150 + 278 382 + */ + const a = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]); + const b = new Float32Array([9, 10, 11, 12, 13, 14, 15, 16]); + const result = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 4], b, [2, 4], MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + + const bt = + new Float32Array([b[0], b[4], b[1], b[5], b[2], b[6], b[3], b[7]]); + const expected = test_util.cpuMultiplyMatrix(a, 2, 4, bt, 4, 2); + test_util.expectArraysClose(result, expected, 0); + }); +}); + +describe('mulmat_packed_gpu (transposed versions)', () => { + it('A * B^t', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 3], b, [2, 3], MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([7, 10, 16, 31]); + expect(c).toEqual(expected); + }); + + it('A^t * B', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [2, 3], b, [2, 3], MatrixOrientation.TRANSPOSED, + MatrixOrientation.REGULAR); + const expected = new Float32Array([17, 12, 2, 22, 15, 4, 27, 18, 6]); + expect(c).toEqual(expected); + }); + + it('A^t * B^t', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const b = new Float32Array([1, 0, 2, 4, 3, 0]); + const c = mulmat_packed_gpu.uploadMultiplyMatrixPackedDownload( + a, [3, 2], b, [2, 3], MatrixOrientation.TRANSPOSED, + MatrixOrientation.TRANSPOSED); + const expected = new Float32Array([11, 13, 14, 20]); + expect(c).toEqual(expected); + }); +}); diff --git a/src/math/webgl/neg_gpu.ts b/src/math/webgl/neg_gpu.ts new file mode 100644 index 0000000000..988b7a8178 --- /dev/null +++ b/src/math/webgl/neg_gpu.ts @@ -0,0 +1,36 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getNegUnaryOp(): string { + return 'gl_FragColor = vec4(-value, 0, 0, 0);'; +} + +export function getFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getNegUnaryOp()); +} + +export function neg( + gpgpu: GPGPUContext, program: WebGLProgram, a: WebGLTexture, rows: number, + columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, program, a, rows, columns, result); +} + +export function uploadNegDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getNegUnaryOp()); +} diff --git a/src/math/webgl/neg_gpu_test.ts b/src/math/webgl/neg_gpu_test.ts new file mode 100644 index 0000000000..ddbd9c8dec --- /dev/null +++ b/src/math/webgl/neg_gpu_test.ts @@ -0,0 +1,50 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as neg_gpu from './neg_gpu'; + +describe('neg_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(28 * 32); + const result = neg_gpu.uploadNegDownload(a, 28, 32); + expect(result.length).toEqual(a.length); + }); + + it('preserves zero values', () => { + const a = new Float32Array([0]); + const result = neg_gpu.uploadNegDownload(a, 1, 1); + expect(result[0]).toBeCloseTo(0); + }); + + it('negates positive values into negative values', () => { + const a = new Float32Array([1]); + const result = neg_gpu.uploadNegDownload(a, 1, 1); + expect(result[0]).toEqual(-1); + }); + + it('negates negative values into positive values', () => { + const a = new Float32Array([-1]); + const result = neg_gpu.uploadNegDownload(a, 1, 1); + expect(result[0]).toEqual(1); + }); + + it('operates on every value in a matrix', () => { + const a = new Float32Array([0.5, 0, -2.3, 4, -12, -Math.E]); + const result = neg_gpu.uploadNegDownload(a, 2, 3); + const expected = new Float32Array([-0.5, 0, 2.3, -4, 12, Math.E]); + test_util.expectArraysClose(result, expected, 0.0001); + }); +}); diff --git a/src/math/webgl/pool_gpu.ts b/src/math/webgl/pool_gpu.ts new file mode 100644 index 0000000000..a588deb33d --- /dev/null +++ b/src/math/webgl/pool_gpu.ts @@ -0,0 +1,121 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; +import {GPGPUContext} from './gpgpu_context'; +import {IS_NAN_SHADER_FUNC} from './webgl_util'; + +export function getFragmentShaderPoolCommonSource( + xShapeRCD: [number, number, number], fSize: number, stride: number, + pad: number, poolType: 'max'|'min'|'avg', computePositions: boolean) { + if (poolType === 'avg' && computePositions) { + throw new Error('Cannot compute positions for average pool.'); + } + + const depth = xShapeRCD[2]; + + const xTexShapeRC = conv_util.computeTexShapeFrom3D(xShapeRCD); + + let returnValue = 'minMaxValue'; + if (computePositions) { + returnValue = 'minMaxPosition'; + } else if (poolType === 'avg') { + returnValue = 'avgValue'; + } + + return ` + precision highp float; + uniform sampler2D x; + varying vec2 resultUV; + + const vec2 halfCR = vec2(0.5, 0.5); + const vec2 xShapeCR = vec2(${xTexShapeRC[1]}, ${xTexShapeRC[0]}); + + ${IS_NAN_SHADER_FUNC} + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d2). + float yR = yTexCR.y; + float yC = floor(yTexCR.x / ${depth}.0); + float d = mod(yTexCR.x, ${depth}.0); + + vec2 xRCCorner = vec2(yR, yC) * vec2(${stride}, ${stride}) - + vec2(${pad}.0, ${pad}.0); + float xRCorner = xRCCorner.x; + float xCCorner = xRCCorner.y; + + // max/min x(?, ?, d) to get y(yR, yC, d). + // ? = to be determined + float minMaxValue = 0.0; + float minMaxValueFound = 0.0; + float minMaxPosition = 0.0; + float avgValue = 0.0; + + for (float wR = 0.0; wR < ${fSize}.0; wR += 1.0) { + float xR = xRCorner + wR; + float xTexR = xR; + + for (float wC = 0.0; wC < ${fSize}.0; wC += 1.0) { + float xC = xCCorner + wC; + float xTexC = xC * ${depth}.0 + d; + + vec2 texCR = vec2(xTexC, xTexR); + + // Check if the requested UV is invalid. + vec2 uv = (texCR + halfCR) / xShapeCR; + bool lessThanZero = any(lessThan(uv, vec2(0, 0))); + bool greaterThanOne = any(greaterThan(uv, vec2(1, 1))); + bool outside = lessThanZero || greaterThanOne; + if (outside) { + continue; + } + + float value = texture2D(x, uv).r; + if (isNaN(value)) { + gl_FragColor = vec4(value, 0, 0, 0); + return; + } + if (${poolType === 'avg'}) { + avgValue += value / ${fSize * fSize}.0; + } else { + // If a min / max value has already been found, use it. If not, use + // the current value. + float currentMinMaxValue = mix( + value, minMaxValue, minMaxValueFound); + if (value ${poolType === 'min' ? '<=' : '>='} currentMinMaxValue) { + minMaxValue = value; + minMaxValueFound = 1.0; + if (${computePositions}) { + minMaxPosition = wR * ${fSize}.0 + wC; + } + } + } + } + } + gl_FragColor = vec4(${returnValue}, 0, 0, 0); + }`; +} + +export function poolCommon( + gpgpu: GPGPUContext, program: WebGLProgram, x: WebGLTexture, + result: WebGLTexture, resultShapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(program); + gpgpu.setInputMatrixTexture(x, 'x', 0); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/reducesum_gpu.ts b/src/math/webgl/reducesum_gpu.ts new file mode 100644 index 0000000000..e3fde5d476 --- /dev/null +++ b/src/math/webgl/reducesum_gpu.ts @@ -0,0 +1,63 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource(rows: number, columns: number): string { + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 resultUV; + + const vec2 aDimCR = vec2(${columns}.0, ${rows}.0); + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + float sum = 0.0; + for (float r = 0.0; r < aDimCR.y; r += 1.0) { + for (float c = 0.0; c < aDimCR.x; c += 1.0) { + vec2 uv = (vec2(c, r) + halfCR) / aDimCR; + sum += texture2D(matrixA, uv).r; + } + } + gl_FragColor = vec4(sum, 0, 0, 0); + }`; +} + +export function reduceSum( + gpgpu: GPGPUContext, reduceSumProgram: WebGLProgram, a: WebGLTexture, + aNumRows: number, aNumCols: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, 1, 1); + gpgpu.setProgram(reduceSumProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} + +export function uploadReduceSumDownload( + a: Float32Array, rows: number, columns: number): number { + const gpgpu = new GPGPUContext(); + const program: WebGLProgram = + gpgpu.createProgram(getFragmentShaderSource(rows, columns)); + const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(1, 1); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + reduceSum(gpgpu, program, aTexture, rows, columns, resultTexture); + const result = gpgpu.downloadMatrixFromTexture(resultTexture, 1, 1)[0]; + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} diff --git a/src/math/webgl/reducesum_gpu_test.ts b/src/math/webgl/reducesum_gpu_test.ts new file mode 100644 index 0000000000..cea94b0ac3 --- /dev/null +++ b/src/math/webgl/reducesum_gpu_test.ts @@ -0,0 +1,65 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as reducesum_gpu from './reducesum_gpu'; + +describe('reducesum_gpu', () => { + it('returns 0 when A is [0]', () => { + const a = new Float32Array(129 * 257); + const result = reducesum_gpu.uploadReduceSumDownload(a, 129, 257); + expect(result).toEqual(0); + }); + + it('returns 1 when A is [1]', () => { + const a = new Float32Array([1]); + const result = reducesum_gpu.uploadReduceSumDownload(a, 1, 1); + expect(result).toEqual(1); + }); + + it('returns 1 when A has one 1', () => { + const a = new Float32Array(100 * 100); + a[49] = 1; + const result = reducesum_gpu.uploadReduceSumDownload(a, 100, 100); + expect(result).toEqual(1); + }); + + it('returns 2 when A has two ones', () => { + const a = new Float32Array(513 * 257); + a[23] = 1; + a[1000] = 1; + const result = reducesum_gpu.uploadReduceSumDownload(a, 513, 257); + expect(result).toEqual(2); + }); + + it('accumulates values from matrix', () => { + const a = test_util.randomArrayInRange(100, -1, 1); + const result = reducesum_gpu.uploadReduceSumDownload(a, 10, 10); + const expected = (() => { + let accum = 0; + for (let i = 0; i < a.length; ++i) { + accum += a[i]; + } + return accum; + })(); + expect(result).toBeCloseTo(expected); + }); + + it('computes 7 from 3x2 [1,2,3,0,0,1]', () => { + const a = new Float32Array([1, 2, 3, 0, 0, 1]); + const result = reducesum_gpu.uploadReduceSumDownload(a, 3, 2); + expect(result).toEqual(7); + }); +}); diff --git a/src/math/webgl/relu_gpu.ts b/src/math/webgl/relu_gpu.ts new file mode 100644 index 0000000000..5e365a3d14 --- /dev/null +++ b/src/math/webgl/relu_gpu.ts @@ -0,0 +1,39 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getReluUnaryOp(): string { + return ` + float result = (value < 0.0 ? 0.0 : value); + gl_FragColor = vec4(result, 0, 0, 0); + `; +} + +export function getFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getReluUnaryOp()); +} + +export function relu( + gpgpu: GPGPUContext, reluProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, reluProgram, a, rows, columns, result); +} + +export function uploadReluDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getReluUnaryOp()); +} diff --git a/src/math/webgl/relu_gpu_test.ts b/src/math/webgl/relu_gpu_test.ts new file mode 100644 index 0000000000..8a7731d849 --- /dev/null +++ b/src/math/webgl/relu_gpu_test.ts @@ -0,0 +1,57 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as relu_gpu from './relu_gpu'; + +describe('relu_gpu', () => { + it('returns a matrix with the shape of the input matrix', () => { + const a = new Float32Array(17 * 257); + const result = relu_gpu.uploadReluDownload(a, 17, 257); + expect(result.length).toEqual(a.length); + }); + + it('does nothing to positive values', () => { + const a = new Float32Array([1]); + const result = relu_gpu.uploadReluDownload(a, 1, 1); + expect(result[0]).toBeCloseTo(a[0]); + }); + + it('sets negative values to 0', () => { + const a = new Float32Array([-1]); + const result = relu_gpu.uploadReluDownload(a, 1, 1); + expect(result[0]).toEqual(0); + }); + + it('preserves zero values', () => { + const a = new Float32Array([0]); + const result = relu_gpu.uploadReluDownload(a, 1, 1); + expect(result[0]).toEqual(0); + }); + + it('operates on multiple values', () => { + const a = new Float32Array([-1, 2, -3, 4, -5, 6, -7, 8, -9]); + const result = relu_gpu.uploadReluDownload(a, 3, 3); + test_util.expectArraysClose( + result, new Float32Array([0, 2, 0, 4, 0, 6, 0, 8, 0]), 0.0001); + }); + + it('propagates NaNs', () => { + const a = new Float32Array([-1, NaN, -3, 4, 6, 0, -3, 1]); + const result = relu_gpu.uploadReluDownload(a, 1, 8); + test_util.expectArraysClose( + result, new Float32Array([0, NaN, 0, 4, 6, 0, 0, 1]), 0.0001); + }); +}); diff --git a/src/math/webgl/render_ndarray_gpu_util.ts b/src/math/webgl/render_ndarray_gpu_util.ts new file mode 100644 index 0000000000..de4d07ccee --- /dev/null +++ b/src/math/webgl/render_ndarray_gpu_util.ts @@ -0,0 +1,59 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +import * as webgl_util from './webgl_util'; + +export function getRenderRGBShader( + gpgpu: GPGPUContext, destinationWidth: number): WebGLProgram { + const fragmentShaderSource = ` + precision highp float; + uniform sampler2D source; + varying vec2 resultUV; + + const float destinationWidth = ${destinationWidth}.0; + const float a = 1.0; + + void main() { + float xr = floor(resultUV.s * destinationWidth) * 3.0; + vec3 x = xr + vec3(0, 1, 2); + + float sourceWidth = destinationWidth * 3.0; + vec3 u = (x + 0.5) / sourceWidth; + float v = 1.0 - resultUV.t; + + float r = texture2D(source, vec2(u[0], v)).r; + float g = texture2D(source, vec2(u[1], v)).r; + float b = texture2D(source, vec2(u[2], v)).r; + + gl_FragColor = vec4(r, g, b, a); + }`; + + return gpgpu.createProgram(fragmentShaderSource); +} + +export function renderToCanvas( + gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) { + webgl_util.bindCanvasToFramebuffer(gpgpu.gl); + renderToFramebuffer(gpgpu, renderShader, sourceTex); +} + +export function renderToFramebuffer( + gpgpu: GPGPUContext, renderShader: WebGLProgram, sourceTex: WebGLTexture) { + gpgpu.setProgram(renderShader); + gpgpu.setInputMatrixTexture(sourceTex, 'source', 0); + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/render_ndarray_gpu_util_test.ts b/src/math/webgl/render_ndarray_gpu_util_test.ts new file mode 100644 index 0000000000..c7d45b3b27 --- /dev/null +++ b/src/math/webgl/render_ndarray_gpu_util_test.ts @@ -0,0 +1,70 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; + +import {GPGPUContext} from './gpgpu_context'; +import * as gpgpu_util from './gpgpu_util'; +import * as render_ndarray_gpu_util from './render_ndarray_gpu_util'; + +function uploadRenderRGBDownload( + source: Float32Array, sourceShapeRowColDepth: [number, number, number]) { + const canvas = document.createElement('canvas'); + canvas.width = sourceShapeRowColDepth[0]; + canvas.height = sourceShapeRowColDepth[1]; + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const program = render_ndarray_gpu_util.getRenderRGBShader( + gpgpu, sourceShapeRowColDepth[1]); + + const sourceTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(sourceShapeRowColDepth); + + const sourceTex = + gpgpu.createMatrixTexture(sourceTexShapeRC[0], sourceTexShapeRC[1]); + gpgpu.uploadMatrixToTexture( + sourceTex, sourceTexShapeRC[0], sourceTexShapeRC[1], source); + + const resultTex = gpgpu_util.createColorMatrixTexture( + gpgpu.gl, sourceShapeRowColDepth[0], sourceShapeRowColDepth[1]); + gpgpu.setOutputMatrixTexture( + resultTex, sourceShapeRowColDepth[0], sourceShapeRowColDepth[1]); + render_ndarray_gpu_util.renderToFramebuffer(gpgpu, program, sourceTex); + + const result = new Float32Array( + sourceShapeRowColDepth[0] * sourceShapeRowColDepth[1] * 4); + gpgpu.gl.readPixels( + 0, 0, sourceShapeRowColDepth[1], sourceShapeRowColDepth[0], gpgpu.gl.RGBA, + gpgpu.gl.FLOAT, result); + return result; +} + +describe('render_gpu', () => { + it('Packs a 1x1x3 vector to a 1x1 color texture', () => { + const source = new Float32Array([1, 2, 3]); + const result = uploadRenderRGBDownload(source, [1, 1, 3]); + expect(result).toEqual(new Float32Array([1, 2, 3, 1])); + }); + + it('Packs a 2x2x3 vector to a 2x2 color texture, mirrored vertically', () => { + const source = new Float32Array([1, 2, 3, 30, 20, 10, 2, 3, 4, 40, 30, 20]); + const result = uploadRenderRGBDownload(source, [2, 2, 3]); + // The resulting rendered image is flipped vertically. + expect(result).toEqual(new Float32Array( + [2, 3, 4, 1, 40, 30, 20, 1, 1, 2, 3, 1, 30, 20, 10, 1])); + }); +}); diff --git a/src/math/webgl/reshape_gpu.ts b/src/math/webgl/reshape_gpu.ts new file mode 100644 index 0000000000..a451a78134 --- /dev/null +++ b/src/math/webgl/reshape_gpu.ts @@ -0,0 +1,65 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../../util'; +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource(): string { + return ` + precision highp float; + uniform sampler2D matrixA; + uniform vec2 inputDimCR; + uniform vec2 resultDimCR; + varying vec2 resultUV; + const vec2 halfCR = vec2(0.5, 0.5); + + void main() { + vec2 resultCR = floor(resultUV * resultDimCR); + // indexInFlat = row * stride + column, where stride == numOutputColumns + float indexInFlat = resultCR.y * resultDimCR.x + resultCR.x; + + vec2 inputCR = vec2( + mod(indexInFlat, inputDimCR.x), // col = indexInFlat % numInputColumns + floor(indexInFlat / inputDimCR.x) // row = indexInFlat / numInputColumns + ) + halfCR; + + vec2 inputUV = inputCR / inputDimCR; + gl_FragColor = texture2D(matrixA, inputUV); + }`; +} + +export function reshape( + gpgpu: GPGPUContext, reshapeProgram: WebGLProgram, a: WebGLTexture, + aNumRows: number, aNumCols: number, result: WebGLTexture, + resultNumRows: number, resultNumCols: number) { + const inputSize = aNumRows * aNumCols; + const outputSize = resultNumCols * resultNumRows; + util.assert( + inputSize === outputSize, + `The input size (${inputSize}) and output size (${outputSize}) ` + + `must match`); + + gpgpu.setOutputMatrixTexture(result, resultNumRows, resultNumCols); + gpgpu.setProgram(reshapeProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + + const inputDimCRLocation = gpgpu.getUniformLocation('inputDimCR'); + gpgpu.gl.uniform2f(inputDimCRLocation, aNumCols, aNumRows); + + const resultDimCRLocation = gpgpu.getUniformLocation('resultDimCR'); + gpgpu.gl.uniform2f(resultDimCRLocation, resultNumCols, resultNumRows); + + gpgpu.executeProgram(); +} diff --git a/src/math/webgl/reshape_gpu_test.ts b/src/math/webgl/reshape_gpu_test.ts new file mode 100644 index 0000000000..0f83a6e69e --- /dev/null +++ b/src/math/webgl/reshape_gpu_test.ts @@ -0,0 +1,88 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as reshape_gpu from './reshape_gpu'; + +describe('reshape_gpu', () => { + let gpgpu: GPGPUContext; + + beforeEach(() => { + gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + }); + + afterEach(() => { + gpgpu.dispose(); + }); + + it('reshape a 2x3 matrix into the same size', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const result = uploadReshapeDownload(a, 2, 3, 2, 3); + expect(result).toEqual(a); + }); + + it('reshape a 2x3 matrix into a column (6x1)', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const result = uploadReshapeDownload(a, 2, 3, 6, 1); + expect(result).toEqual(a); + }); + + it('reshape a 2x3 matrix into a row (1x6) vector', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const result = uploadReshapeDownload(a, 2, 3, 1, 6); + expect(result).toEqual(a); + }); + + it('reshape a 2x3 into a 3x2 matrix', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const result = uploadReshapeDownload(a, 2, 3, 3, 2); + expect(result).toEqual(a); + }); + + it('reshape a 2x3 into a 3x1 causes an error', () => { + const a = new Float32Array([1, 2, 3, 4, 5, 6]); + const f = () => { + uploadReshapeDownload(a, 2, 3, 3, 1); + }; + + expect(f).toThrowError(); + }); + + function uploadReshapeDownload( + a: Float32Array, aNumRows: number, aNumCols: number, + resultNumRows: number, resultNumCols: number): Float32Array { + const program = gpgpu.createProgram(reshape_gpu.getFragmentShaderSource()); + + const aTexture = gpgpu.createMatrixTexture(aNumRows, aNumCols); + gpgpu.uploadMatrixToTexture(aTexture, aNumRows, aNumCols, a); + + const resultTexture: WebGLTexture = + gpgpu.createMatrixTexture(resultNumRows, resultNumCols); + + reshape_gpu.reshape( + gpgpu, program, aTexture, aNumRows, aNumCols, resultTexture, + resultNumRows, resultNumCols); + + const result = gpgpu.downloadMatrixFromTexture( + resultTexture, resultNumRows, resultNumCols); + + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + + return result; + } +}); diff --git a/src/math/webgl/resize_bilinear_gpu.ts b/src/math/webgl/resize_bilinear_gpu.ts new file mode 100644 index 0000000000..ec57158227 --- /dev/null +++ b/src/math/webgl/resize_bilinear_gpu.ts @@ -0,0 +1,92 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as conv_util from '../conv_util'; + +import {GPGPUContext} from './gpgpu_context'; +import * as webgl_util from './webgl_util'; + +export function getFragmentShaderSource( + inputShapeRCD: [number, number, number], + outputDimensionsRowCol: [number, number], alignCorners: boolean): string { + const depth = inputShapeRCD[2]; + + const inputTexShapeRC = conv_util.computeTexShapeFrom3D(inputShapeRCD); + + const effectiveInputShapeRCD = alignCorners ? + [inputShapeRCD[0] - 1, inputShapeRCD[1] - 1, depth] : + inputShapeRCD; + + const effectiveOutputShapeRCD = alignCorners ? + [outputDimensionsRowCol[0] - 1, outputDimensionsRowCol[1] - 1, depth] : + [outputDimensionsRowCol[0], outputDimensionsRowCol[1], depth]; + + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 resultUV; + const vec2 halfCR = vec2(0.5, 0.5); + + const vec2 inputShapeCR = vec2(${inputShapeRCD[1]}, ${inputShapeRCD[0]}); + const vec2 inputShapeTexCR = vec2( + ${inputTexShapeRC[1]}, ${inputTexShapeRC[0]}); + + const vec2 effectiveInputOverOutputRatioCR = vec2( + ${effectiveInputShapeRCD[1] / effectiveOutputShapeRCD[1]}, + ${effectiveInputShapeRCD[0] / effectiveOutputShapeRCD[0]}); + + float sampleInput(float col, float row, float d) { + vec2 uv = (vec2(col * ${depth}.0 + d, row) + halfCR) / inputShapeTexCR; + return texture2D(matrixA, uv).r; + } + + void main() { + vec2 yTexCR = floor(gl_FragCoord.xy); + + // Map from 2D (yTexR, yTexC) to 3D (yR, yC, d). + vec2 yCR = vec2(floor(yTexCR.x / ${depth}.0), yTexCR.y); + float d = mod(yTexCR.x, ${depth}.0); + + // Fractional source index. + vec2 sourceFracIndexCR = yCR * effectiveInputOverOutputRatioCR; + + // Compute the four integer indices. + vec2 sourceFloorCR = floor(sourceFracIndexCR); + vec2 sourceCeilCR = min(inputShapeCR - 1.0, ceil(sourceFracIndexCR)); + + float topLeft = sampleInput(sourceFloorCR[0], sourceFloorCR[1], d); + float bottomLeft = sampleInput(sourceFloorCR[0], sourceCeilCR[1], d); + float topRight = sampleInput(sourceCeilCR[0], sourceFloorCR[1], d); + float bottomRight = sampleInput(sourceCeilCR[0], sourceCeilCR[1], d); + + vec2 fracCR = sourceFracIndexCR - sourceFloorCR; + + float top = topLeft + (topRight - topLeft) * fracCR[0]; + float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR[0]; + float newValue = top + (bottom - top) * fracCR[1]; + + gl_FragColor = vec4(newValue, 0.0, 0.0, 0.0); + }`; +} + +export function resizeBilinear( + gpgpu: GPGPUContext, resizeBilinearProgram: WebGLProgram, a: WebGLTexture, + result: WebGLTexture, resultShapeRowCol: [number, number]) { + gpgpu.setOutputMatrixTexture( + result, resultShapeRowCol[0], resultShapeRowCol[1]); + gpgpu.setProgram(resizeBilinearProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} \ No newline at end of file diff --git a/src/math/webgl/resize_bilinear_gpu_test.ts b/src/math/webgl/resize_bilinear_gpu_test.ts new file mode 100644 index 0000000000..e0d20e78bd --- /dev/null +++ b/src/math/webgl/resize_bilinear_gpu_test.ts @@ -0,0 +1,127 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as conv_util from '../conv_util'; +import {NDArrayMathCPU} from '../math_cpu'; +import {Array3D, NDArray} from '../ndarray'; + +import {GPGPUContext} from './gpgpu_context'; +import * as resize_bilinear_gpu from './resize_bilinear_gpu'; + +describe('resize bilinear', () => { + function uploadResizeBilinearDownload( + a: Float32Array, aShapeRowColDepth: [number, number, number], + outputDimensionsRowCol: [number, number], + alignCorners: boolean): Float32Array { + const aTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(aShapeRowColDepth); + + const resultShapeRCD: [number, number, number] = [ + outputDimensionsRowCol[0], outputDimensionsRowCol[1], aShapeRowColDepth[2] + ]; + + const resultTexShapeRC: [number, number] = + conv_util.computeTexShapeFrom3D(resultShapeRCD); + + const gpgpu = new GPGPUContext(); + gpgpu.enableAutomaticDebugValidation(true); + + const shaderSource = resize_bilinear_gpu.getFragmentShaderSource( + aShapeRowColDepth, outputDimensionsRowCol, alignCorners); + const program = gpgpu.createProgram(shaderSource); + + const aTex = gpgpu.createMatrixTexture(aTexShapeRC[0], aTexShapeRC[1]); + const resultTex = + gpgpu.createMatrixTexture(resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.uploadMatrixToTexture(aTex, aTexShapeRC[0], aTexShapeRC[1], a); + + resize_bilinear_gpu.resizeBilinear( + gpgpu, program, aTex, resultTex, resultTexShapeRC); + + const result = gpgpu.downloadMatrixFromTexture( + resultTex, resultTexShapeRC[0], resultTexShapeRC[1]); + + gpgpu.deleteMatrixTexture(resultTex); + gpgpu.deleteMatrixTexture(aTex); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; + } + + it('simple bilinear', () => { + const a = new Float32Array([2, 2, 4, 4]); + + const result = uploadResizeBilinearDownload(a, [2, 2, 1], [3, 3], false); + + test_util.expectArraysClose( + result, new Float32Array([2, 2, 2, 10 / 3, 10 / 3, 10 / 3, 4, 4, 4]), + 1e-4); + }); + + it('simple alignCorners=true', () => { + const a = new Float32Array([2, 2, 4, 4]); + + const result = uploadResizeBilinearDownload(a, [2, 2, 1], [3, 3], true); + + test_util.expectArraysClose( + result, new Float32Array([2, 2, 2, 3, 3, 3, 4, 4, 4]), 1e-4); + }); + + it('matches tensorflow w/ random numbers alignCorners=false', () => { + const a = new Float32Array([ + 1.19074044, 0.91373104, 2.01611669, -0.52270832, 0.38725395, 1.30809779, + 0.61835143, 3.49600659, 2.09230986, 0.56473997, 0.03823943, 1.19864896 + ]); + + const result = uploadResizeBilinearDownload(a, [2, 3, 2], [4, 5], false); + + test_util.expectArraysClose( + result, new Float32Array([ + 1.19074047, 0.91373104, 1.68596613, 0.05186744, 1.69034398, + -0.15654698, 0.7130264, 0.94193673, 0.38725394, 1.30809784, + 0.9045459, 2.20486879, 1.59434628, 0.89455694, 1.68591988, + 0.26748738, 0.58103991, 1.00690198, 0.21274668, 1.25337338, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893, + 0.6183514, 3.49600649, 1.50272655, 1.73724651, 1.68149579, + 0.69152176, 0.44905344, 1.07186723, 0.03823943, 1.19864893 + ]), + 1e-4); + }); + + it('matches tensorflow w/ random numbers alignCorners=true', () => { + const a = new Float32Array([ + 1.56324531, 2.13817752, 1.44398421, 1.07632684, 0.59306785, -0.36970865, + 1.62451879, 1.8367334, 1.13944798, 2.01993218, 2.01919952, 2.67524054 + ]); + + const result = uploadResizeBilinearDownload(a, [2, 3, 2], [4, 5], true); + + test_util.expectArraysClose( + result, new Float32Array([ + 1.5632453, 2.13817763, 1.50361478, 1.60725224, 1.44398427, + 1.07632685, 1.01852608, 0.35330909, 0.59306782, -0.36970866, + 1.58366978, 2.03769612, 1.46307099, 1.71427906, 1.3424722, + 1.39086199, 1.20545864, 1.01806819, 1.06844509, 0.6452744, + 1.60409427, 1.93721485, 1.42252707, 1.82130599, 1.24096, + 1.70539713, 1.3923912, 1.68282723, 1.54382229, 1.66025746, + 1.62451875, 1.83673346, 1.38198328, 1.92833281, 1.13944793, + 2.01993227, 1.57932377, 2.34758639, 2.01919961, 2.67524052 + ]), + 1e-4); + }); +}); \ No newline at end of file diff --git a/src/math/webgl/shader_compiler.ts b/src/math/webgl/shader_compiler.ts new file mode 100644 index 0000000000..f87bde891c --- /dev/null +++ b/src/math/webgl/shader_compiler.ts @@ -0,0 +1,126 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from '../../util'; +import {NDArray} from '../ndarray'; + +export type Input = { + name: string; array: NDArray; +}; + +export function makeShaderKey(inputs: NDArray[], output: NDArray): string { + const ins = inputs.map(x => x.shape + '_' + x.getTextureShapeRC()); + return ins.join('_') + '_' + output.shape + '_' + output.getTextureShapeRC(); +} + +export function makeShader( + inputs: Input[], output: NDArray, userCode: string): string { + const inputPrefixSnippet = + inputs.map(x => `uniform sampler2D ${x.name};`).join('\n'); + const inputSamplingSnippet = + inputs.map(x => getInputSamplingSnippet(x)).join('\n'); + const outTexShape = output.getTextureShapeRC(); + const outputSamplingSnippet = + getOutputSamplingSnippet(output.shape, outTexShape); + const source = [ + SHADER_PREFIX, inputPrefixSnippet, SAMPLE_2D_SNIPPET, inputSamplingSnippet, + outputSamplingSnippet, userCode + ].join('\n'); + return source; +} + +function getInputSamplingSnippet(input: Input) { + const arr = input.array; + const shape = arr.shape; + const texShape = arr.getTextureShapeRC(shape as [number, number]); + switch (shape.length) { + case 2: + return getSampler2D(input.name, shape as [number, number], texShape); + default: + throw new Error(`${arr.rank}-D input sampling is not yet supported`); + } +} + +function getOutputSamplingSnippet( + outShape: number[], outTexShape: [number, number]): string { + switch (outShape.length) { + case 2: + return getOutput2DCoords(outShape as [number, number], outTexShape); + default: + throw new Error( + `${outShape.length}-D output sampling is not yet supported`); + } +} + +const SHADER_PREFIX = ` + precision highp float; + varying vec2 resultUV; + const vec2 halfCR = vec2(0.5, 0.5); + + void setOutput(float val) { + gl_FragColor = vec4(val, 0, 0, 0); + } +`; + +const SAMPLE_2D_SNIPPET = ` + float sample2D(sampler2D texture, float texNumR, float texNumC, float numC, + float row, float col) { + float index = dot(vec2(row, col), vec2(numC, 1.0)); + float texR = floor(index / texNumC); + float texC = mod(index, texNumC); + vec2 uv = (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR); + return texture2D(texture, uv).r; + } +`; + +function getOutput2DCoords( + shape: [number, number], texShape: [number, number]) { + if (util.arraysEqual(shape, texShape)) { + return ` + vec2 getOutputCoords() { + return floor(gl_FragCoord.yx); + } + `; + } + return ` + vec2 getOutputCoords() { + vec2 resTexRC = floor(gl_FragCoord.yx); + float index = dot(resTexRC, vec2(${texShape[1]}.0, 1.0)); + float r = floor(index / ${shape[1]}.0); + float c = mod(index, ${shape[1]}.0); + return vec2(r, c); + } + `; +} + +function getSampler2D( + texName: string, shape: [number, number], texShape: [number, number]) { + const funcName = 'get' + texName.charAt(0).toUpperCase() + texName.slice(1); + const tR = texShape[0]; + const tC = texShape[1]; + if (util.arraysEqual(shape, texShape)) { + return ` + float ${funcName}(float row, float col) { + vec2 uv = (vec2(col, row) + halfCR) / vec2(${tC}.0, ${tR}.0); + return texture2D(${texName}, uv).r; + } + `; + } + return ` + float ${funcName}(float row, float col) { + return sample2D(${texName}, ${tR}.0, ${tC}.0, ${shape[1]}.0, row, col); + } + `; +} diff --git a/src/math/webgl/sigmoid_gpu.ts b/src/math/webgl/sigmoid_gpu.ts new file mode 100644 index 0000000000..eff7dfa296 --- /dev/null +++ b/src/math/webgl/sigmoid_gpu.ts @@ -0,0 +1,37 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getSigmoidUnaryOp(): string { + return 'gl_FragColor = vec4(1.0 / (1.0 + exp(-1.0 * value)), 0, 0, 0);'; +} + +export function getSigmoidFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getSigmoidUnaryOp()); +} + +export function sigmoid( + gpgpu: GPGPUContext, sigmoidProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, sigmoidProgram, a, rows, columns, result); +} + +export function uploadSigmoidDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload( + a, rows, columns, getSigmoidUnaryOp()); +} \ No newline at end of file diff --git a/src/math/webgl/sigmoid_gpu_test.ts b/src/math/webgl/sigmoid_gpu_test.ts new file mode 100644 index 0000000000..68b032926d --- /dev/null +++ b/src/math/webgl/sigmoid_gpu_test.ts @@ -0,0 +1,38 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as util from '../../util'; +import * as sigmoid_gpu from './sigmoid_gpu'; + +describe('sigmoid_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(28 * 32); + const result = sigmoid_gpu.uploadSigmoidDownload(a, 28, 32); + expect(result.length).toEqual(a.length); + }); + + it('Sigmoid equals CPU', () => { + const size = 10; + const a = test_util.randomArrayInRange(size, -1, 1); + const expectedResult = new Float32Array(size); + for (let i = 0; i < a.length; i++) { + expectedResult[i] = 1 / (1 + Math.exp(-a[i])); + } + + const result = sigmoid_gpu.uploadSigmoidDownload(a, 1, size); + test_util.expectArraysClose(result, expectedResult, 1e-6); + }); +}); diff --git a/src/math/webgl/step_gpu.ts b/src/math/webgl/step_gpu.ts new file mode 100644 index 0000000000..f61bcc5272 --- /dev/null +++ b/src/math/webgl/step_gpu.ts @@ -0,0 +1,39 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +function getStepUnaryOp(): string { + return ` + float res = value == value ? (value > 0.0 ? 1.0 : 0.0) : value; + gl_FragColor = vec4(res, 0, 0, 0); + `; +} + +export function getFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getStepUnaryOp()); +} + +export function step( + gpgpu: GPGPUContext, stepProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, stepProgram, a, rows, columns, result); +} + +export function uploadStepDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getStepUnaryOp()); +} diff --git a/src/math/webgl/step_gpu_test.ts b/src/math/webgl/step_gpu_test.ts new file mode 100644 index 0000000000..7b207ad580 --- /dev/null +++ b/src/math/webgl/step_gpu_test.ts @@ -0,0 +1,65 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as step_gpu from './step_gpu'; + +describe('step_gpu', () => { + it('returns a matrix with the shape of the input matrix', () => { + const a = new Float32Array(67 * 901); + const result = step_gpu.uploadStepDownload(a, 67, 901); + expect(result.length).toEqual(a.length); + }); + + it('preserves zeroes from the input matrix', () => { + const a = new Float32Array(1); + const result = step_gpu.uploadStepDownload(a, 1, 1); + expect(result[0]).toEqual(0); + }); + + it('preserves ones from the input matrix', () => { + const a = new Float32Array([1]); + const result = step_gpu.uploadStepDownload(a, 1, 1); + expect(result[0]).toEqual(a[0]); + }); + + it('transforms negative values to zeroes', () => { + const a = new Float32Array([-123.45]); + const result = step_gpu.uploadStepDownload(a, 1, 1); + expect(result[0]).toEqual(0); + }); + + it('transforms positive values to ones', () => { + const a = new Float32Array([0.1]); + const result = step_gpu.uploadStepDownload(a, 1, 1); + expect(result[0]).toEqual(1); + }); + + it('operates on every element of a matrix', () => { + const a = new Float32Array(24); + a.fill(0.1); + const result = step_gpu.uploadStepDownload(a, 4, 6); + const expected = new Float32Array(a.length); + expected.fill(1); + test_util.expectArraysClose(result, expected, 0); + }); + + it('operates on a heterogeneous matrix', () => { + const a = new Float32Array([-1, 0, 100, -0.001]); + const result = step_gpu.uploadStepDownload(a, 4, 1); + const expected = new Float32Array([0, 0, 1, 0]); + test_util.expectArraysClose(result, expected, 0); + }); +}); diff --git a/src/math/webgl/tex_util.ts b/src/math/webgl/tex_util.ts new file mode 100644 index 0000000000..ae4a5815d0 --- /dev/null +++ b/src/math/webgl/tex_util.ts @@ -0,0 +1,233 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export function getUnpackedMatrixTextureShapeWidthHeight( + rows: number, columns: number): [number, number] { + return [columns, rows]; +} + +export function getUnpackedArraySizeFromMatrixSize( + matrixSize: number, channelsPerTexture: number): number { + return matrixSize * channelsPerTexture; +} + +export function getColorMatrixTextureShapeWidthHeight( + rows: number, columns: number): [number, number] { + return [columns * 4, rows]; +} + +export function getMatrixSizeFromUnpackedArraySize( + unpackedSize: number, channelsPerTexture: number): number { + if (unpackedSize % channelsPerTexture !== 0) { + throw new Error( + 'unpackedSize (' + unpackedSize + ') must be a multiple of ' + + channelsPerTexture); + } + return unpackedSize / channelsPerTexture; +} + +export function encodeMatrixToUnpackedArray( + matrix: Float32Array, unpackedArray: Float32Array, + channelsPerTexture: number) { + const requiredSize = + getUnpackedArraySizeFromMatrixSize(matrix.length, channelsPerTexture); + if (unpackedArray.length < requiredSize) { + throw new Error( + 'unpackedArray length (' + unpackedArray.length + + ') must be >= ' + requiredSize); + } + let dst = 0; + for (let src = 0; src < matrix.length; ++src) { + unpackedArray[dst] = matrix[src]; + dst += channelsPerTexture; + } +} + +export function decodeMatrixFromUnpackedArray( + unpackedArray: Float32Array, matrix: Float32Array, + channelsPerTexture: number) { + const requiredSize = getMatrixSizeFromUnpackedArraySize( + unpackedArray.length, channelsPerTexture); + if (matrix.length < requiredSize) { + throw new Error( + 'matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + let dst = 0; + for (let src = 0; src < unpackedArray.length; src += channelsPerTexture) { + matrix[dst++] = unpackedArray[src]; + } +} + +export function getPackedMatrixTextureShapeWidthHeight( + rows: number, columns: number): [number, number] { + return [Math.ceil(columns / 2), Math.ceil(rows / 2)]; +} + +export function getPackedRGBAArraySizeFromMatrixShape( + rows: number, columns: number): number { + const [w, h] = getPackedMatrixTextureShapeWidthHeight(rows, columns); + return w * h * 4; +} + +export function encodeMatrixToPackedRGBA( + matrix: Float32Array, rows: number, columns: number, + packedRGBA: Float32Array) { + const requiredSize = getPackedRGBAArraySizeFromMatrixShape(rows, columns); + if (packedRGBA.length < requiredSize) { + throw new Error( + 'packedRGBA length (' + packedRGBA.length + + ') must be >= ' + requiredSize); + } + /* + Unpacked matrix, row-major order in Float32Array[16]: A B C D + E F G H + I J K L + M N O P + + Packed matrix, 2x2 RGBA32 texture (memory view): ABEF CDGH IJMN KLOP + + Packed matrix, 2x2 RGBA32 texture (matrix view): AB|CD + EF|GH + --+-- + IJ|KL + MN|OP + */ + const [textureWidth, textureHeight] = + getPackedMatrixTextureShapeWidthHeight(rows, columns); + const oddWidth = (columns % 2) === 1; + const oddHeight = (rows % 2) === 1; + const widthInFullBlocks = Math.floor(columns / 2); + const heightInFullBlocks = Math.floor(rows / 2); + + // loop over full 2x2 blocks + { + const dstStride = (oddWidth ? 4 : 0); + const oneRow = columns; + let dst = 0; + for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) { + const matrixSrcRow = (blockY * 2 * columns); + for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) { + const matrixSrcCol = blockX * 2; + const src = matrixSrcRow + matrixSrcCol; + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 1] = matrix[src + 1]; + packedRGBA[dst + 2] = matrix[src + oneRow]; + packedRGBA[dst + 3] = matrix[src + oneRow + 1]; + dst += 4; + } + dst += dstStride; + } + } + + // loop down final odd column + if (oddWidth) { + let src = columns - 1; + let dst = (textureWidth - 1) * 4; + const srcStride = 2 * columns; + const dstStride = textureWidth * 4; + for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) { + packedRGBA[dst] = matrix[src]; + packedRGBA[dst + 2] = matrix[src + columns]; + src += srcStride; + dst += dstStride; + } + } + + // loop across final row + if (oddHeight) { + let src = (rows - 1) * columns; + let dst = (textureHeight - 1) * textureWidth * 4; + for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) { + packedRGBA[dst++] = matrix[src++]; + packedRGBA[dst++] = matrix[src++]; + dst += 2; + } + } + + // fill in bottom-right texel + if (oddWidth && oddHeight) { + packedRGBA[packedRGBA.length - 4] = matrix[matrix.length - 1]; + } + + return packedRGBA; +} + +export function decodeMatrixFromPackedRGBA( + packedRGBA: Float32Array, rows: number, columns: number, + matrix: Float32Array): Float32Array { + const requiredSize = rows * columns; + if (requiredSize < matrix.length) { + throw new Error( + 'matrix length (' + matrix.length + ') must be >= ' + requiredSize); + } + const oddWidth = (columns % 2) === 1; + const oddHeight = (rows % 2) === 1; + const widthInFullBlocks = Math.floor(columns / 2); + const heightInFullBlocks = Math.floor(rows / 2); + const [textureWidth, textureHeight] = + getPackedMatrixTextureShapeWidthHeight(rows, columns); + + // loop over full 2x2 blocks + { + const srcStride = oddWidth ? 4 : 0; + const dstStride = columns + (oddWidth ? 1 : 0); + let src = 0; + let dstRow1 = 0; + let dstRow2 = columns; + for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) { + for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow1++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + matrix[dstRow2++] = packedRGBA[src++]; + } + src += srcStride; + dstRow1 += dstStride; + dstRow2 += dstStride; + } + } + + // loop down final column + if (oddWidth) { + let src = (textureWidth - 1) * 4; + let dst = columns - 1; + const srcStride = textureWidth * 4; + const dstStride = 2 * columns; + for (let blockY = 0; blockY < heightInFullBlocks; ++blockY) { + matrix[dst] = packedRGBA[src]; + matrix[dst + columns] = packedRGBA[src + 2]; + src += srcStride; + dst += dstStride; + } + } + + // loop across final row + if (oddHeight) { + let src = (textureHeight - 1) * textureWidth * 4; + let dst = (rows - 1) * columns; + for (let blockX = 0; blockX < widthInFullBlocks; ++blockX) { + matrix[dst++] = packedRGBA[src++]; + matrix[dst++] = packedRGBA[src++]; + src += 2; + } + } + + // fill in bottom-right cell + if (oddWidth && oddHeight) { + matrix[matrix.length - 1] = packedRGBA[packedRGBA.length - 4]; + } + + return matrix; +} diff --git a/src/math/webgl/tex_util_test.ts b/src/math/webgl/tex_util_test.ts new file mode 100644 index 0000000000..c278a924b0 --- /dev/null +++ b/src/math/webgl/tex_util_test.ts @@ -0,0 +1,301 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as tex_util from './tex_util'; + +describe('tex_util getUnpackedMatrixTextureShapeWidthHeight', () => { + it('[1x1] => [1x1]', () => { + expect(tex_util.getUnpackedMatrixTextureShapeWidthHeight(1, 1)).toEqual([ + 1, 1 + ]); + }); + + it('[MxN] => [NxM]', () => { + expect(tex_util.getUnpackedMatrixTextureShapeWidthHeight(123, 456)) + .toEqual([456, 123]); + }); +}); + +describe('tex_util getPackedMatrixTextureShapeWidthHeight', () => { + it('[1x1] => [1x1]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(1, 1); + expect(shape).toEqual([1, 1]); + }); + + it('[1x2] => [1x1]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(1, 2); + expect(shape).toEqual([1, 1]); + }); + + it('[2x1] => [1x1]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(2, 1); + expect(shape).toEqual([1, 1]); + }); + + it('[2x2] => [1x1]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(2, 2); + expect(shape).toEqual([1, 1]); + }); + + it('[3x3] => [2x2]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(3, 3); + expect(shape).toEqual([2, 2]); + }); + + it('[4x3] => [2x2]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(4, 3); + expect(shape).toEqual([2, 2]); + }); + + it('[3x4] => [2x2]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(3, 4); + expect(shape).toEqual([2, 2]); + }); + + it('[4x4] => [2x2]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(4, 4); + expect(shape).toEqual([2, 2]); + }); + + it('[1024x1024] => [512x512]', () => { + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(1024, 1024); + expect(shape).toEqual([512, 512]); + }); + + it('[MxN] => [ceil(N/2)xceil(M/2)]', () => { + const M = 123; + const N = 5013; + const shape = tex_util.getPackedMatrixTextureShapeWidthHeight(M, N); + expect(shape).toEqual([Math.ceil(N / 2), Math.ceil(M / 2)]); + }); +}); + +describe('tex_util encodeMatrixToUnpackedArray, channels = 4', () => { + it('1x1 writes the only matrix array value to the only texel', () => { + const matrix = new Float32Array([1]); + const unpackedRGBA = new Float32Array([0, 0, 0, 0]); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 4); + test_util.expectArraysClose( + unpackedRGBA, new Float32Array([1, 0, 0, 0]), 0); + }); + + it('1x1 can upload texels with values greater than 1', () => { + const matrix = new Float32Array([100]); + const unpackedRGBA = new Float32Array([0, 0, 0, 0]); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 4); + test_util.expectArraysClose( + unpackedRGBA, new Float32Array([100, 0, 0, 0]), 0); + }); + + it('1x4 each texel has 4 elements with matrix value in R channel', () => { + const matrix = new Float32Array([1, 2, 3, 4]); + const unpackedRGBA = new Float32Array(16); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 4); + test_util.expectArraysClose( + unpackedRGBA, + new Float32Array([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0]), 0); + }); +}); + +describe('tex_util encodeMatrixToUnpackedArray, channels = 1', () => { + it('1x1 writes the only matrix array value to the only texel', () => { + const matrix = new Float32Array([1]); + const unpackedRGBA = new Float32Array([0]); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 1); + test_util.expectArraysClose(unpackedRGBA, new Float32Array([1]), 0); + }); + + it('1x1 can upload texels with values greater than 1', () => { + const matrix = new Float32Array([100]); + const unpackedRGBA = new Float32Array([0]); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 1); + test_util.expectArraysClose(unpackedRGBA, new Float32Array([100]), 0); + }); + + it('1x4 each texel has 4 elements with matrix value in R channel', () => { + const matrix = new Float32Array([1, 2, 3, 4]); + const unpackedRGBA = new Float32Array(4); + tex_util.encodeMatrixToUnpackedArray(matrix, unpackedRGBA, 1); + test_util.expectArraysClose( + unpackedRGBA, new Float32Array([1, 2, 3, 4]), 0); + }); +}); + +describe('tex_util decodeMatrixFromUnpackedArray', () => { + it('1x1 writes the only matrix array value to the first element', () => { + const unpackedRGBA = new Float32Array([1, 0, 0, 0]); + const matrix = new Float32Array(1); + tex_util.decodeMatrixFromUnpackedArray(unpackedRGBA, matrix, 4); + expect(matrix.length).toEqual(1); + expect(matrix[0]).toEqual(1); + }); + + it('1x2 writes the second texel R component to the second element', () => { + const unpackedRGBA = new Float32Array([1, 0, 0, 0, 2, 0, 0, 0]); + const matrix = new Float32Array(2); + tex_util.decodeMatrixFromUnpackedArray(unpackedRGBA, matrix, 4); + expect(matrix.length).toEqual(2); + test_util.expectArraysClose(matrix, new Float32Array([1, 2]), 0); + }); +}); + +describe('tex_util encodeMatrixToPackedRGBA', () => { + it('1x1 loads the element into R and 0\'s into GBA', () => { + const matrix = new Float32Array([1]); + const packedRGBA = new Float32Array(4); + tex_util.encodeMatrixToPackedRGBA(matrix, 1, 1, packedRGBA); + test_util.expectArraysClose(packedRGBA, new Float32Array([1, 0, 0, 0]), 0); + }); + + it('1x2 loads the second element into G and 0\'s into BA', () => { + const matrix = new Float32Array([1, 2]); + const packedRGBA = new Float32Array(4); + tex_util.encodeMatrixToPackedRGBA(matrix, 1, 2, packedRGBA); + test_util.expectArraysClose(packedRGBA, new Float32Array([1, 2, 0, 0]), 0); + }); + + it('2x1 loads the second element into G and 0\'s into BA', () => { + const matrix = new Float32Array([1, 2]); + const packedRGBA = new Float32Array(4); + tex_util.encodeMatrixToPackedRGBA(matrix, 2, 1, packedRGBA); + test_util.expectArraysClose(packedRGBA, new Float32Array([1, 0, 2, 0]), 0); + }); + + it('2x2 exactly fills one texel', () => { + const matrix = new Float32Array([1, 2, 3, 4]); + const packedRGBA = new Float32Array(4); + tex_util.encodeMatrixToPackedRGBA(matrix, 2, 2, packedRGBA); + test_util.expectArraysClose(packedRGBA, new Float32Array([1, 2, 3, 4]), 0); + }); + + it('4x3 pads the final column G and A channels with 0', () => { + /* + 1 2 3 1 2 4 5 | 3 0 6 0 + 4 5 6 => -----------+----------- + 7 8 9 7 8 10 11 | 9 0 12 0 + 10 11 12 + */ + const matrix = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const packedRGBA = new Float32Array(16); + tex_util.encodeMatrixToPackedRGBA(matrix, 4, 3, packedRGBA); + test_util.expectArraysClose( + packedRGBA, + new Float32Array([1, 2, 4, 5, 3, 0, 6, 0, 7, 8, 10, 11, 9, 0, 12, 0]), + 0); + }); + + it('3x4 pads the final row B and A channels with 0', () => { + /* + 1 2 3 4 1 2 5 6 | 3 4 7 8 + 5 6 7 8 => ---------+---------- + 9 10 11 12 9 10 0 0 | 11 12 0 0 + */ + const matrix = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + const packedRGBA = new Float32Array(16); + tex_util.encodeMatrixToPackedRGBA(matrix, 3, 4, packedRGBA); + test_util.expectArraysClose( + packedRGBA, + new Float32Array([1, 2, 5, 6, 3, 4, 7, 8, 9, 10, 0, 0, 11, 12, 0, 0]), + 0); + }); + + it('3x3 bottom-right texel is R000', () => { + /* + 1 2 3 1 2 4 5 | 3 0 6 0 + 4 5 6 => --------+-------- + 7 8 9 7 8 0 0 | 9 0 0 0 + */ + const matrix = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9]); + const packedRGBA = new Float32Array(16); + tex_util.encodeMatrixToPackedRGBA(matrix, 3, 3, packedRGBA); + test_util.expectArraysClose( + packedRGBA, + new Float32Array([1, 2, 4, 5, 3, 0, 6, 0, 7, 8, 0, 0, 9, 0, 0, 0]), 0); + }); +}); + +describe('tex_util decodeMatrixFromPackedRGBA', () => { + it('1x1 matrix only loads R component from only texel', () => { + const packedRGBA = new Float32Array([1, 0, 0, 0]); + const matrix = new Float32Array(1); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 1, 1, matrix); + expect(matrix[0]).toEqual(1); + }); + + it('1x2 matrix loads RG from only texel', () => { + const packedRGBA = new Float32Array([1, 2, 0, 0]); + const matrix = new Float32Array(2); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 1, 2, matrix); + test_util.expectArraysClose(matrix, new Float32Array([1, 2]), 0); + }); + + it('2x1 matrix loads RB from only texel', () => { + const packedRGBA = new Float32Array([1, 0, 2, 0]); + const matrix = new Float32Array(2); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 2, 1, matrix); + test_util.expectArraysClose(matrix, new Float32Array([1, 2]), 0); + }); + + it('2x2 matrix loads RGBA from only texel', () => { + const packedRGBA = new Float32Array([1, 2, 3, 4]); + const matrix = new Float32Array(4); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 2, 2, matrix); + test_util.expectArraysClose(matrix, new Float32Array([1, 2, 3, 4]), 0); + }); + + it('4x3 final column only reads RB from edge texels', () => { + /* + 1 2 4 5 | 3 0 6 0 1 2 3 + -----------+----------- => 4 5 6 + 7 8 10 11 | 9 0 12 0 7 8 9 + 10 11 12 + */ + const packedRGBA = + new Float32Array([1, 2, 4, 5, 3, 0, 6, 0, 7, 8, 10, 11, 9, 0, 12, 0]); + const matrix = new Float32Array(12); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 4, 3, matrix); + test_util.expectArraysClose( + matrix, new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), 0); + }); + + it('3x4 final row only reads RG from edge texels', () => { + /* + 1 2 5 6 | 3 4 7 8 1 2 3 4 + ---------+---------- => 5 6 7 8 + 9 10 0 0 | 11 12 0 0 9 10 11 12 + */ + const packedRGBA = + new Float32Array([1, 2, 5, 6, 3, 4, 7, 8, 9, 10, 0, 0, 11, 12, 0, 0]); + const matrix = new Float32Array(12); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 3, 4, matrix); + test_util.expectArraysClose( + matrix, new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), 0); + }); + + it('3x3 bottom-right only reads R from corner texel', () => { + /* + 1 2 4 5 | 3 0 6 0 1 2 3 + --------+-------- => 4 5 6 + 7 8 0 0 | 9 0 0 0 7 8 9 + */ + const packedRGBA = + new Float32Array([1, 2, 4, 5, 3, 0, 6, 0, 7, 8, 0, 0, 9, 0, 0, 0]); + const matrix = new Float32Array(9); + tex_util.decodeMatrixFromPackedRGBA(packedRGBA, 3, 3, matrix); + test_util.expectArraysClose( + matrix, new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9]), 0); + }); +}); diff --git a/src/math/webgl/texture_manager.ts b/src/math/webgl/texture_manager.ts new file mode 100644 index 0000000000..6aa8374676 --- /dev/null +++ b/src/math/webgl/texture_manager.ts @@ -0,0 +1,92 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export class TextureManager { + private numUsedTextures = 0; + private numFreeTextures = 0; + private freeTextures: {[shape: string]: WebGLTexture[]} = {}; + private logEnabled = false; + private usedTextureCount: {[shape: string]: number} = {}; + + constructor(private gpgpu: GPGPUContext) {} + + acquireTexture(shapeRC: [number, number]): WebGLTexture { + const shapeKey = getKeyFromTextureShape(shapeRC); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + if (!(shapeKey in this.usedTextureCount)) { + this.usedTextureCount[shapeKey] = 0; + } + this.usedTextureCount[shapeKey]++; + + if (this.freeTextures[shapeKey].length > 0) { + this.numFreeTextures--; + this.numUsedTextures++; + this.log(); + return this.freeTextures[shapeKey].shift()!; + } + this.numUsedTextures++; + this.log(); + + return this.gpgpu.createMatrixTexture(shapeRC[0], shapeRC[1]); + } + + releaseTexture(texture: WebGLTexture, shape: [number, number]): void { + const shapeKey = getKeyFromTextureShape(shape); + if (!(shapeKey in this.freeTextures)) { + this.freeTextures[shapeKey] = []; + } + this.freeTextures[shapeKey].push(texture); + this.numFreeTextures++; + this.numUsedTextures--; + this.usedTextureCount[shapeKey]--; + this.log(); + } + + private log() { + if (!this.logEnabled) { + return; + } + const total = this.numFreeTextures + this.numUsedTextures; + console.log( + 'Free/Used', this.numFreeTextures + ' / ' + this.numUsedTextures, + `(${total})`); + } + + getNumUsedTextures(): number { + return this.numUsedTextures; + } + + getNumFreeTextures(): number { + return this.numFreeTextures; + } + + dispose() { + for (const shape in this.freeTextures) { + if (this.freeTextures.hasOwnProperty(shape)) { + for (let i = 0; i < this.freeTextures[shape].length; i++) { + this.gpgpu.deleteMatrixTexture(this.freeTextures[shape][i]); + } + } + } + } +} + +function getKeyFromTextureShape(shapeRowsCol: [number, number]): string { + return shapeRowsCol[0] + '_' + shapeRowsCol[1]; +} diff --git a/src/math/webgl/trig_gpu.ts b/src/math/webgl/trig_gpu.ts new file mode 100644 index 0000000000..e4edd6cf71 --- /dev/null +++ b/src/math/webgl/trig_gpu.ts @@ -0,0 +1,66 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; +import * as unaryop_gpu from './unaryop_gpu'; + +/** + * Sine + */ +function getSinUnaryOp(): string { + return ` + gl_FragColor = vec4(sin(value), 0, 0, 0); + `; +} + +export function getSinFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getSinUnaryOp()); +} + +export function sin( + gpgpu: GPGPUContext, sinProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, sinProgram, a, rows, columns, result); +} + +export function uploadSinDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getSinUnaryOp()); +} + +/** + * Tanh + */ +function getTanhUnaryOp(): string { + return ` + float e2x = exp(-2.0 * value); + gl_FragColor = vec4((1.0 - e2x) / (1.0 + e2x), 0, 0, 0); + `; +} + +export function getTanhFragmentShaderSource(): string { + return unaryop_gpu.getFragmentShaderSource(getTanhUnaryOp()); +} + +export function tanh( + gpgpu: GPGPUContext, tanhProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + unaryop_gpu.unaryOp(gpgpu, tanhProgram, a, rows, columns, result); +} + +export function uploadTanhDownload( + a: Float32Array, rows: number, columns: number): Float32Array { + return unaryop_gpu.uploadUnaryOpDownload(a, rows, columns, getTanhUnaryOp()); +} diff --git a/src/math/webgl/trig_gpu_test.ts b/src/math/webgl/trig_gpu_test.ts new file mode 100644 index 0000000000..8f6bfe9f67 --- /dev/null +++ b/src/math/webgl/trig_gpu_test.ts @@ -0,0 +1,57 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as test_util from '../../test_util'; +import * as util from '../../util'; +import * as trig_gpu from './trig_gpu'; + +describe('sin_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(28 * 32); + const result = trig_gpu.uploadSinDownload(a, 28, 32); + expect(result.length).toEqual(a.length); + }); + + it('Sin equals CPU', () => { + const size = 10; + const a = test_util.randomArrayInRange(size, -1, 1); + const expectedResult = new Float32Array(size); + for (let i = 0; i < a.length; i++) { + expectedResult[i] = Math.sin(a[i]); + } + const result = trig_gpu.uploadSinDownload(a, 1, size); + test_util.expectArraysClose(result, expectedResult, 1e-3); + }); +}); + + +describe('tanh_gpu', () => { + it('returns a matrix with the same shape as the input matrix', () => { + const a = new Float32Array(28 * 32); + const result = trig_gpu.uploadTanhDownload(a, 28, 32); + expect(result.length).toEqual(a.length); + }); + + it('Tanh equals CPU', () => { + const size = 10; + const a = test_util.randomArrayInRange(size, -1, 1); + const expectedResult = new Float32Array(size); + for (let i = 0; i < a.length; i++) { + expectedResult[i] = util.tanh(a[i]); + } + const result = trig_gpu.uploadTanhDownload(a, 1, size); + test_util.expectArraysClose(result, expectedResult, 1e-6); + }); +}); diff --git a/src/math/webgl/unaryop_gpu.ts b/src/math/webgl/unaryop_gpu.ts new file mode 100644 index 0000000000..76181eb68a --- /dev/null +++ b/src/math/webgl/unaryop_gpu.ts @@ -0,0 +1,55 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {GPGPUContext} from './gpgpu_context'; + +export function getFragmentShaderSource(resultOp: string): string { + return ` + precision highp float; + uniform sampler2D matrixA; + varying vec2 resultUV; + + void main() { + float value = texture2D(matrixA, resultUV).r; + ${resultOp} + }`; +} + +export function unaryOp( + gpgpu: GPGPUContext, unaryOpProgram: WebGLProgram, a: WebGLTexture, + rows: number, columns: number, result: WebGLTexture) { + gpgpu.setOutputMatrixTexture(result, rows, columns); + gpgpu.setProgram(unaryOpProgram); + gpgpu.setInputMatrixTexture(a, 'matrixA', 0); + gpgpu.executeProgram(); +} + +export function uploadUnaryOpDownload( + a: Float32Array, rows: number, columns: number, + resultOp: string): Float32Array { + const gpgpu = new GPGPUContext(); + const fragmentShaderSrc = getFragmentShaderSource(resultOp); + const program: WebGLProgram = gpgpu.createProgram(fragmentShaderSrc); + const aTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns); + const resultTexture: WebGLTexture = gpgpu.createMatrixTexture(rows, columns); + gpgpu.uploadMatrixToTexture(aTexture, rows, columns, a); + unaryOp(gpgpu, program, aTexture, rows, columns, resultTexture); + const result = gpgpu.downloadMatrixFromTexture(resultTexture, rows, columns); + gpgpu.deleteMatrixTexture(aTexture); + gpgpu.deleteMatrixTexture(resultTexture); + gpgpu.deleteProgram(program); + gpgpu.dispose(); + return result; +} diff --git a/src/math/webgl/webgl_util.ts b/src/math/webgl/webgl_util.ts new file mode 100644 index 0000000000..1238393f21 --- /dev/null +++ b/src/math/webgl/webgl_util.ts @@ -0,0 +1,418 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +let USE_WEBGL2_WHEN_AVAILABLE = false; +let WEBGL2_ENABLED: boolean|undefined = null!; +let MAX_TEXTURE_SIZE: number = null!; + +import * as util from '../../util'; + +export interface WebGLContextAttributes { + alpha?: boolean; + antialias?: boolean; + premultipliedAlpha?: boolean; + preserveDrawingBuffer?: boolean; + depth?: boolean; + stencil?: boolean; + failIfMajorPerformanceCaveat?: boolean; +} + +/** @hidden */ +export const IS_NAN_SHADER_FUNC = ` +bool isNaN(float val) { + return val == val ? false : true; +} +`; + +export interface WebGLLoseContextExtension { loseContext(): void; } + +export function createWebGLRenderingContext(attributes: WebGLContextAttributes): + WebGLRenderingContext { + const canvas = document.createElement('canvas'); + canvas.width = 1; + canvas.height = 1; + return createWebGLRenderingContextFromCanvas(canvas, attributes); +} + +/** + * Force the library to prefer WebGL 1.0 instead of WebGL 2.0 even when WebGL + * 2.0 is available. + */ +export function preferWebGL1() { + USE_WEBGL2_WHEN_AVAILABLE = false; + WEBGL2_ENABLED = undefined; +} + +/** + * Prefer WebGL 2.0 to WebGL 1.0. This is the default configuration. + */ +export function preferWebGL2() { + USE_WEBGL2_WHEN_AVAILABLE = true; + WEBGL2_ENABLED = undefined; +} + +export function isWebGL2Enabled() { + if (!USE_WEBGL2_WHEN_AVAILABLE) { + return false; + } + + if (WEBGL2_ENABLED === undefined) { + const tempCanvas = document.createElement('canvas'); + const gl = tempCanvas.getContext('webgl2'); + if (gl != null) { + WEBGL2_ENABLED = true; + + const loseContextExtension = + getExtensionOrThrow( + gl as WebGLRenderingContext, 'WEBGL_lose_context') as + WebGLLoseContextExtension; + loseContextExtension.loseContext(); + } else { + WEBGL2_ENABLED = false; + } + } + return WEBGL2_ENABLED; +} + +export function createWebGLRenderingContextFromCanvas( + canvas: HTMLCanvasElement, + attributes: WebGLContextAttributes): WebGLRenderingContext { + let gl: WebGLRenderingContext; + if (isWebGL2Enabled()) { + gl = canvas.getContext('webgl2', attributes) as WebGLRenderingContext; + } else { + gl = (canvas.getContext('webgl', attributes) || + canvas.getContext('experimental-webgl', attributes)) as + WebGLRenderingContext; + } + + if (gl == null) { + throw new Error('This browser does not support WebGL.'); + } + return gl; +} + +export function callAndCheck(gl: WebGLRenderingContext, func: () => T): T { + const returnValue = func(); + checkWebGLError(gl); + return returnValue; +} + +let webGLDebugErrorCheckingEnabled = false; + +export function enableDebugWebGLErrorChecking(enabled: boolean) { + webGLDebugErrorCheckingEnabled = enabled; +} + +export function checkWebGLError(gl: WebGLRenderingContext) { + if (webGLDebugErrorCheckingEnabled) { + const error = gl.getError(); + if (error !== gl.NO_ERROR) { + throw new Error('WebGL Error: ' + getWebGLErrorMessage(gl, error)); + } + } +} + +export function getWebGLErrorMessage( + gl: WebGLRenderingContext, status: number): string { + switch (status) { + case gl.NO_ERROR: + return 'NO_ERROR'; + case gl.INVALID_ENUM: + return 'INVALID_ENUM'; + case gl.INVALID_VALUE: + return 'INVALID_VALUE'; + case gl.INVALID_OPERATION: + return 'INVALID_OPERATION'; + case gl.INVALID_FRAMEBUFFER_OPERATION: + return 'INVALID_FRAMEBUFFER_OPERATION'; + case gl.OUT_OF_MEMORY: + return 'OUT_OF_MEMORY'; + case gl.CONTEXT_LOST_WEBGL: + return 'CONTEXT_LOST_WEBGL'; + default: + return 'Unknown error code ' + status; + } +} + +export function getExtensionOrThrow( + gl: WebGLRenderingContext, extensionName: string): {} { + return throwIfNull<{}>( + gl, () => gl.getExtension(extensionName), + 'Extension "' + extensionName + '" not supported on this browser.'); +} + +export function createVertexShader( + gl: WebGLRenderingContext, vertexShaderSource: string): WebGLShader { + const vertexShader: WebGLShader = throwIfNull( + gl, () => gl.createShader(gl.VERTEX_SHADER), + 'Unable to create vertex WebGLShader.'); + callAndCheck(gl, () => gl.shaderSource(vertexShader, vertexShaderSource)); + callAndCheck(gl, () => gl.compileShader(vertexShader)); + if (gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(vertexShader)); + throw new Error('Failed to compile vertex shader.'); + } + return vertexShader; +} + +export function createFragmentShader( + gl: WebGLRenderingContext, fragmentShaderSource: string): WebGLShader { + const fragmentShader: WebGLShader = throwIfNull( + gl, () => gl.createShader(gl.FRAGMENT_SHADER), + 'Unable to create fragment WebGLShader.'); + callAndCheck(gl, () => gl.shaderSource(fragmentShader, fragmentShaderSource)); + callAndCheck(gl, () => gl.compileShader(fragmentShader)); + if (gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS) === false) { + console.log(gl.getShaderInfoLog(fragmentShader)); + throw new Error('Failed to compile fragment shader.'); + } + return fragmentShader; +} + +export function createProgram(gl: WebGLRenderingContext): WebGLProgram { + return throwIfNull( + gl, () => gl.createProgram(), 'Unable to create WebGLProgram.'); +} + +export function linkProgram(gl: WebGLRenderingContext, program: WebGLProgram) { + callAndCheck(gl, () => gl.linkProgram(program)); + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Failed to link vertex and fragment shaders.'); + } +} + +export function validateProgram( + gl: WebGLRenderingContext, program: WebGLProgram) { + callAndCheck(gl, () => gl.validateProgram(program)); + if (gl.getProgramParameter(program, gl.VALIDATE_STATUS) === false) { + console.log(gl.getProgramInfoLog(program)); + throw new Error('Shader program validation failed.'); + } +} + +export function createStaticVertexBuffer( + gl: WebGLRenderingContext, data: Float32Array): WebGLBuffer { + const buffer: WebGLBuffer = throwIfNull( + gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer'); + callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer)); + callAndCheck(gl, () => gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)); + return buffer; +} + +export function createStaticIndexBuffer( + gl: WebGLRenderingContext, data: Uint16Array): WebGLBuffer { + const buffer: WebGLBuffer = throwIfNull( + gl, () => gl.createBuffer(), 'Unable to create WebGLBuffer'); + callAndCheck(gl, () => gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer)); + callAndCheck( + gl, () => gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW)); + return buffer; +} + +export function queryMaxTextureSize(gl: WebGLRenderingContext): number { + if (MAX_TEXTURE_SIZE != null) { + return MAX_TEXTURE_SIZE; + } + MAX_TEXTURE_SIZE = + callAndCheck(gl, () => gl!.getParameter(gl!.MAX_TEXTURE_SIZE)); + return MAX_TEXTURE_SIZE; +} + +export function getChannelsPerTexture(): number { + if (isWebGL2Enabled()) { + return 1; + } + return 4; +} + +export function createTexture(gl: WebGLRenderingContext): WebGLTexture { + return throwIfNull( + gl, () => gl.createTexture(), 'Unable to create WebGLTexture.'); +} + +export function validateTextureSize( + gl: WebGLRenderingContext, width: number, height: number) { + const maxTextureSize: number = queryMaxTextureSize(gl); + if ((width <= 0) || (height <= 0)) { + const requested = '[' + width + 'x' + height + ']'; + throw new Error('Requested texture size ' + requested + ' is invalid.'); + } + if ((width > maxTextureSize) || (height > maxTextureSize)) { + const requested = '[' + width + 'x' + height + ']'; + const max = '[' + maxTextureSize + 'x' + maxTextureSize + ']'; + throw new Error( + 'Requested texture size ' + requested + + ' greater than WebGL maximum on this browser / GPU ' + max + '.'); + } +} + +export function createFramebuffer(gl: WebGLRenderingContext): WebGLFramebuffer { + return throwIfNull( + gl, () => gl.createFramebuffer(), 'Unable to create WebGLFramebuffer.'); +} + +export function bindVertexBufferToProgramAttribute( + gl: WebGLRenderingContext, program: WebGLProgram, attribute: string, + buffer: WebGLBuffer, arrayEntriesPerItem: number, itemStrideInBytes: number, + itemOffsetInBytes: number) { + const loc = gl.getAttribLocation(program, attribute); + if (loc === -1) { + const error = new Error( + 'Unable to get attribute "' + attribute + '" on WebGLProgram.'); + // tslint:disable-next-line:no-any + (error as any).namedVertexAttributeNotFound = attribute; + throw error; + } + callAndCheck(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, buffer)); + callAndCheck( + gl, + () => gl.vertexAttribPointer( + loc, arrayEntriesPerItem, gl.FLOAT, false, itemStrideInBytes, + itemOffsetInBytes)); + callAndCheck(gl, () => gl.enableVertexAttribArray(loc)); +} + +export function bindTextureUnit( + gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit)); + callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture)); +} + +export function unbindTextureUnit( + gl: WebGLRenderingContext, textureUnit: number) { + validateTextureUnit(gl, textureUnit); + callAndCheck(gl, () => gl.activeTexture(gl.TEXTURE0 + textureUnit)); + callAndCheck(gl, () => gl.bindTexture(gl.TEXTURE_2D, null)); +} + +export function getProgramUniformLocationOrThrow( + gl: WebGLRenderingContext, program: WebGLProgram, + uniformName: string): WebGLUniformLocation { + return throwIfNull( + gl, () => gl.getUniformLocation(program, uniformName), + 'uniform "' + uniformName + '" not present in program.'); +} + +export function bindTextureToProgramUniformSampler( + gl: WebGLRenderingContext, program: WebGLProgram, texture: WebGLTexture, + uniformSamplerName: string, textureUnit: number) { + callAndCheck(gl, () => bindTextureUnit(gl, texture, textureUnit)); + const samplerLocation = + getProgramUniformLocationOrThrow(gl, program, uniformSamplerName); + callAndCheck(gl, () => gl.uniform1i(samplerLocation, textureUnit)); +} + +export function bindCanvasToFramebuffer(gl: WebGLRenderingContext) { + callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, null)); + callAndCheck(gl, () => gl.viewport(0, 0, gl.canvas.width, gl.canvas.height)); + callAndCheck(gl, () => gl.scissor(0, 0, gl.canvas.width, gl.canvas.height)); +} + +export function bindColorTextureToFramebuffer( + gl: WebGLRenderingContext, texture: WebGLTexture, + framebuffer: WebGLFramebuffer) { + callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)); + callAndCheck( + gl, + () => gl.framebufferTexture2D( + gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0)); +} + +export function unbindColorTextureFromFramebuffer( + gl: WebGLRenderingContext, framebuffer: WebGLFramebuffer) { + callAndCheck(gl, () => gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)); + callAndCheck( + gl, + () => gl.framebufferTexture2D( + gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, null, 0)); +} + +export function validateFramebuffer(gl: WebGLRenderingContext) { + const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + if (status !== gl.FRAMEBUFFER_COMPLETE) { + throw new Error( + 'Error binding framebuffer: ' + getFramebufferErrorMessage(gl, status)); + } +} + +export function getFramebufferErrorMessage( + gl: WebGLRenderingContext, status: number): string { + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + return 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + return 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'; + case gl.FRAMEBUFFER_UNSUPPORTED: + return 'FRAMEBUFFER_UNSUPPORTED'; + default: + return 'unknown error ' + status; + } +} + +function throwIfNull( + gl: WebGLRenderingContext, returnTOrNull: () => T | null, + failureMessage: string): T { + const tOrNull: T|null = callAndCheck(gl, () => returnTOrNull()); + if (tOrNull == null) { + throw new Error(failureMessage); + } + return tOrNull as T; +} + +function validateTextureUnit(gl: WebGLRenderingContext, textureUnit: number) { + const maxTextureUnit = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1; + const glTextureUnit = textureUnit + gl.TEXTURE0; + if (glTextureUnit < gl.TEXTURE0 || glTextureUnit > maxTextureUnit) { + const textureUnitRange = '[gl.TEXTURE0, gl.TEXTURE' + maxTextureUnit + ']'; + throw new Error('textureUnit must be in ' + textureUnitRange + '.'); + } +} + +export function getTextureShapeFromLogicalShape( + gl: WebGLRenderingContext, logicalShape: number[], + preferredTexShape?: [number, number]): [number, number] { + const maxTexSize = queryMaxTextureSize(gl); + const size = util.sizeFromShape(logicalShape); + if (preferredTexShape != null) { + const sizePreferred = util.sizeFromShape(preferredTexShape); + util.assert( + size === sizePreferred, + `Size of shape (${size}) must match size of ` + + `preferredShape (${sizePreferred})`); + if (preferredTexShape[0] <= maxTexSize && + preferredTexShape[1] <= maxTexSize) { + return preferredTexShape; + } + } + + if (logicalShape.length <= 1 && size <= maxTexSize) { + return [size, 1]; + } else if ( + logicalShape.length === 2 && logicalShape[0] <= maxTexSize && + logicalShape[1] <= maxTexSize) { + return logicalShape as [number, number]; + } else if ( + logicalShape.length === 3 && logicalShape[0] <= maxTexSize && + logicalShape[1] * logicalShape[2] <= maxTexSize) { + return [logicalShape[0], logicalShape[1] * logicalShape[2]]; + } else { + return util.sizeToSquarishShape(size); + } +} diff --git a/src/operation_emitter.ts b/src/operation_emitter.ts new file mode 100644 index 0000000000..220d775868 --- /dev/null +++ b/src/operation_emitter.ts @@ -0,0 +1,125 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {AddNode, ArgMaxEqualsNode, ArgMaxNode, Concat3DNode, Convolution2DNode, DivideNode, ExpNode, FusedLinearCombinationNode, Graph, LogNode, MatMulNode, MaxPoolNode, MeanSquaredCostNode, MultiplyNode, Node, ReduceSumNode, ReLUNode, ReshapeNode, SigmoidNode, SoftmaxCrossEntropyCostNode, SoftmaxNode, SplitNode, SquareNode, SubtractNode, TanHNode, Tensor} from './graph'; +import * as graph_util from './graph_util'; +import {Add} from './ops/add'; +import {ArgMax} from './ops/argmax'; +import {ArgMaxEquals} from './ops/argmaxequals'; +import {Concat3D} from './ops/concat3d'; +import {Convolution2D} from './ops/convolution'; +import {Divide} from './ops/divide'; +import {ReLU, Sigmoid, Square, TanH} from './ops/element_wise_activation'; +import {MeanSquaredCost} from './ops/element_wise_cost'; +import {Exp} from './ops/exp'; +import {LinearCombination} from './ops/linear_combination'; +import {Log} from './ops/log'; +import {MatMul} from './ops/matmul'; +import {MaxPool} from './ops/max_pool'; +import {Multiply} from './ops/multiply'; +import {Operation} from './ops/op'; +import {ReduceSum} from './ops/reduce_sum'; +import {Reshape} from './ops/reshape'; +import {Softmax, SoftmaxCrossEntropyCost} from './ops/softmax'; +import {Split} from './ops/split'; +import {Subtract} from './ops/subtract'; + +export function emitFromGraphNodes(nodes: Node[]): Operation[] { + const ops: Operation[] = []; + nodes.forEach(node => Array.prototype.push.apply(ops, emitOpFromNode(node))); + return ops; +} + +function emitOpFromNode(node: Node): Operation[] { + if (node instanceof ReshapeNode) { + return [new Reshape(node.inputs[ReshapeNode.X], node.output)]; + } else if (node instanceof MatMulNode) { + const x1 = node.inputs[MatMulNode.X1]; + const x2 = node.inputs[MatMulNode.X2]; + return [new MatMul(x1, x2, node.output)]; + } else if (node instanceof Convolution2DNode) { + const w = node.inputs[Convolution2DNode.W]; + const x = node.inputs[Convolution2DNode.X]; + const b = node.inputs[Convolution2DNode.B]; + return [new Convolution2D( + w, x, b, node.output, node.fieldSize, node.outputDepth, node.stride, + node.zeroPad)]; + } else if (node instanceof MaxPoolNode) { + const x = node.inputs[MaxPoolNode.X]; + return [new MaxPool( + x, node.output, node.fieldSize, node.stride, node.zeroPad)]; + } else if (node instanceof ExpNode) { + return [new Exp(node.inputs[ExpNode.X], node.output)]; + } else if (node instanceof LogNode) { + return [new Log(node.inputs[LogNode.X], node.output)]; + } else if (node instanceof ReLUNode) { + return [new ReLU(node.inputs[ReLUNode.X], node.output)]; + } else if (node instanceof TanHNode) { + return [new TanH(node.inputs[TanHNode.X], node.output)]; + } else if (node instanceof SigmoidNode) { + return [new Sigmoid(node.inputs[SigmoidNode.X], node.output)]; + } else if (node instanceof SoftmaxCrossEntropyCostNode) { + const x = node.inputs[SoftmaxCrossEntropyCostNode.X]; + const target = node.inputs[SoftmaxCrossEntropyCostNode.TARGET]; + return [new SoftmaxCrossEntropyCost(x, target, node.output)]; + } else if (node instanceof SoftmaxNode) { + return [new Softmax(node.inputs[SoftmaxNode.X], node.output)]; + } else if (node instanceof MeanSquaredCostNode) { + const label = node.inputs[MeanSquaredCostNode.LABEL]; + const prediction = node.inputs[MeanSquaredCostNode.PREDICTION]; + return [new MeanSquaredCost(label, prediction, node.output)]; + } else if (node instanceof ArgMaxEqualsNode) { + return [new ArgMaxEquals( + node.inputs[ArgMaxEqualsNode.X1], node.inputs[ArgMaxEqualsNode.X2], + node.output)]; + } else if (node instanceof ArgMaxNode) { + return [new ArgMax(node.x, node.output)]; + } else if (node instanceof FusedLinearCombinationNode) { + return [new LinearCombination( + node.inputs[FusedLinearCombinationNode.T1], + node.inputs[FusedLinearCombinationNode.T2], + node.inputs[FusedLinearCombinationNode.C1], + node.inputs[FusedLinearCombinationNode.C2], node.output)]; + } else if (node instanceof Concat3DNode) { + return [new Concat3D( + node.inputs[Concat3DNode.X1], node.inputs[Concat3DNode.X2], node.axis, + node.output)]; + } else if (node instanceof SquareNode) { + return [new Square(node.inputs[SquareNode.X], node.output)]; + } else if (node instanceof AddNode) { + return [new Add( + node.inputs[AddNode.T1], node.inputs[AddNode.T2], node.output)]; + } else if (node instanceof SubtractNode) { + return [new Subtract( + node.inputs[SubtractNode.T1], node.inputs[SubtractNode.T2], + node.output)]; + } else if (node instanceof MultiplyNode) { + return [new Multiply( + node.inputs[MultiplyNode.T1], node.inputs[MultiplyNode.T2], + node.output)]; + } else if (node instanceof DivideNode) { + return [new Divide( + node.inputs[DivideNode.T1], node.inputs[DivideNode.T2], node.output)]; + } else if (node instanceof SplitNode) { + return [new Split(node.inputs[SplitNode.X], node.outputs)]; + } else if (node instanceof ReduceSumNode) { + return [new ReduceSum(node.inputs[ReduceSumNode.X], node.output)]; + } else if (graph_util.isInputNode(node)) { + return []; + } else { + // tslint:disable-next-line:no-any + throw Error('Unsupported node type: ' + (node.constructor as any).name); + } +} diff --git a/src/ops/add.ts b/src/ops/add.ts new file mode 100644 index 0000000000..2d391c5a6e --- /dev/null +++ b/src/ops/add.ts @@ -0,0 +1,102 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Add extends Operation { + private dySizeScalar: Scalar; + + /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private yTensor: Tensor) { + super(); + util.assert( + util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), + 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + let result: NDArray; + if (util.isScalarShape(x1.shape)) { + result = math.scalarPlusArray(x1, x2); + } else if (util.isScalarShape(x2.shape)) { + result = math.scalarPlusArray(x2, x1); + } else { + result = math.add(x1, x2); + } + inferenceArrays.set(this.yTensor, keep(result)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + const dy = gradientArrays.get(this.yTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.x1Tensor)) { + if (util.isScalarShape(this.x1Tensor.shape)) { + const sum = math.sum(dy); + if (this.dySizeScalar == null) { + this.dySizeScalar = Scalar.new(dy.size); + } + gradientArrays.set( + this.x1Tensor, keep(math.divide(sum, this.dySizeScalar))); + } else { + gradientArrays.set(this.x1Tensor, dy); + } + } + + if (graph_util.shouldBackProp(this.x2Tensor)) { + if (util.isScalarShape(this.x2Tensor.shape)) { + const sum = math.sum(dy); + if (this.dySizeScalar == null) { + this.dySizeScalar = Scalar.new(dy.size); + } + gradientArrays.set( + this.x2Tensor, keep(math.divide(sum, this.dySizeScalar))); + } else { + gradientArrays.set(this.x2Tensor, dy); + } + } + }); + } + + dispose() { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + } +} diff --git a/src/ops/add_test.ts b/src/ops/add_test.ts new file mode 100644 index 0000000000..78e45cf109 --- /dev/null +++ b/src/ops/add_test.ts @@ -0,0 +1,193 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Add} from './add'; + +describe('add operation', () => { + let math: NDArrayMathCPU; + + let t1: Tensor; + let t2: Tensor; + let y: Tensor; + let addOp: Add; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(t1); + activations.disposeArray(t2); + activations.disposeArray(y); + gradients.disposeArray(t1); + gradients.disposeArray(t2); + gradients.disposeArray(y); + }); + + it('adds two 1-D tensors', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array1D.new([3, 4, 5]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + addOp = new Add(t1, t2, y); + addOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([3]); + expect(yVal.getValues()).toEqual(new Float32Array([4, 6, 8])); + + const dy = Array1D.new([6, 7, 8]); + gradients.set(y, dy); + + addOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(dy.getValues()); + }); + + it('adds two 2-D tensors', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Array2D.new([2, 3], [3, 4, 5, 7, 8, 9]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + addOp = new Add(t1, t2, y); + addOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([4, 6, 8, 11, 13, 15])); + + const dy = Array2D.new([2, 3], [10, 11, 12, 13, 14, 15]); + gradients.set(y, dy); + + addOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(dy.getValues()); + }); + + it('ndarray + scalar', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Scalar.new(2); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + addOp = new Add(t1, t2, y); + addOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([3, 4, 5, 6, 7, 8])); + + const dy = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + gradients.set(y, dy); + + addOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.get()).toEqual(7); + }); + + it('scalar + array', () => { + const x1 = Scalar.new(2); + const x2 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + addOp = new Add(t1, t2, y); + addOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([3, 4, 5, 6, 7, 8])); + + const dy = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + gradients.set(y, dy); + + addOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.get()).toEqual(7); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(dy.getValues()); + }); + + it('throws when shapes of X1 and X2 do not match', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Array2D.new([3, 2], [1, 2, 3, 4, 5, 6]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + expect(() => new Add(t1, t2, y)).toThrowError(); + }); +}); diff --git a/src/ops/argmax.ts b/src/ops/argmax.ts new file mode 100644 index 0000000000..762d77e503 --- /dev/null +++ b/src/ops/argmax.ts @@ -0,0 +1,47 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMath} from '../math/math'; +import {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class ArgMax extends Operation { + /** + * An ArgMax operation. + */ + constructor(private xTensor: Tensor, private yTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor); + math.scope((keep) => { + inferenceArrays.set(this.yTensor, keep(math.argMax(x))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + throw new Error('ArgMax backprop unimplemented'); + } +} diff --git a/src/ops/argmax_test.ts b/src/ops/argmax_test.ts new file mode 100644 index 0000000000..e833dac6e1 --- /dev/null +++ b/src/ops/argmax_test.ts @@ -0,0 +1,67 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {ArgMax} from './argmax'; + +describe('Argmax oper', () => { + let math: NDArrayMathCPU; + + let x: Tensor; + let y: Tensor; + let tensorArrayMap: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + tensorArrayMap = new TensorArrayMap(); + }); + + afterEach(() => { + tensorArrayMap.disposeArray(x); + tensorArrayMap.disposeArray(y); + }); + + it('argmax of Array1D', () => { + const vals = Array1D.new([0, 2, 1]); + x = new Tensor(vals.shape); + y = new Tensor([]); + tensorArrayMap.set(x, vals); + + const argmaxOp = new ArgMax(x, y); + argmaxOp.feedForward(math, tensorArrayMap); + const yVal = tensorArrayMap.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.get()).toEqual(1); + }); + + it('argmax of Array2D', () => { + const vals = Array2D.new([2, 3], [[0, 2, 1], [2, 3, 0]]); + x = new Tensor(vals.shape); + y = new Tensor([]); + tensorArrayMap.set(x, vals); + + const argmaxOp = new ArgMax(x, y); + argmaxOp.feedForward(math, tensorArrayMap); + const yVal = tensorArrayMap.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.get()).toEqual(4); + }); +}); diff --git a/src/ops/argmaxequals.ts b/src/ops/argmaxequals.ts new file mode 100644 index 0000000000..e6656c0ebe --- /dev/null +++ b/src/ops/argmaxequals.ts @@ -0,0 +1,50 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMath} from '../math/math'; +import {Array1D, Array2D, NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class ArgMaxEquals extends Operation { + /** + * An ArgMaxEquals operation. + */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private yTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + math.scope((keep) => { + inferenceArrays.set(this.yTensor, keep(math.argMaxEquals(x1, x2))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + throw new Error('ArgMaxEquals backprop unimplemented'); + } +} diff --git a/src/ops/argmaxequals_test.ts b/src/ops/argmaxequals_test.ts new file mode 100644 index 0000000000..5fa45bad00 --- /dev/null +++ b/src/ops/argmaxequals_test.ts @@ -0,0 +1,80 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {ArgMaxEquals} from './argmaxequals'; + +describe('Argmax equals oper', () => { + let math: NDArrayMathCPU; + + let t1: Tensor; + let t2: Tensor; + let y: Tensor; + let argmaxEqualsOp: ArgMaxEquals; + let tensorArrayMap: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + tensorArrayMap = new TensorArrayMap(); + }); + + afterEach(() => { + tensorArrayMap.disposeArray(t1); + tensorArrayMap.disposeArray(t2); + tensorArrayMap.disposeArray(y); + }); + + it('argmax equals', () => { + const x1 = Array1D.new([0, 2, 1]); + const x2 = Array1D.new([2, 4, 3]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + tensorArrayMap.set(t1, x1); + tensorArrayMap.set(t2, x2); + + argmaxEqualsOp = new ArgMaxEquals(t1, t2, y); + argmaxEqualsOp.feedForward(math, tensorArrayMap); + const yVal = tensorArrayMap.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.getValues()).toEqual(new Float32Array([1])); + }); + + it('argmax not equals', () => { + const x1 = Array1D.new([0, 2, 1]); + const x2 = Array1D.new([5, 4, 3]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + tensorArrayMap.set(t1, x1); + tensorArrayMap.set(t2, x2); + + argmaxEqualsOp = new ArgMaxEquals(t1, t2, y); + argmaxEqualsOp.feedForward(math, tensorArrayMap); + const yVal = tensorArrayMap.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.getValues()).toEqual(new Float32Array([0])); + }); +}); \ No newline at end of file diff --git a/src/ops/concat3d.ts b/src/ops/concat3d.ts new file mode 100644 index 0000000000..2c82c6b89b --- /dev/null +++ b/src/ops/concat3d.ts @@ -0,0 +1,57 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as concat3d_util from '../math/concat3d_util'; +import {NDArrayMath} from '../math/math'; +import {Array3D, NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Concat3D extends Operation { + /** + * A Concat 3D operation. + * + * Concats two 3D tensors along an axis. + */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, private axis: number, + private yTensor: Tensor) { + super(); + concat3d_util.assertConcat3DShapesMatch( + x1Tensor.shape, x2Tensor.shape, axis); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor) as Array3D; + const x2 = inferenceArrays.get(this.x2Tensor) as Array3D; + + math.scope((keep) => { + const concatResult = math.concat3D(x1, x2, this.axis); + inferenceArrays.set(this.yTensor, keep(concatResult)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + throw new Error('Concat3D backprop not implemented.'); + } +} diff --git a/src/ops/concat3d_test.ts b/src/ops/concat3d_test.ts new file mode 100644 index 0000000000..48b7619eb9 --- /dev/null +++ b/src/ops/concat3d_test.ts @@ -0,0 +1,115 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as concat3d_util from '../math/concat3d_util'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array3D} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Concat3D} from './concat3d'; + +describe('concat3d operation', () => { + let math: NDArrayMathCPU; + + let x1Tensor: Tensor; + let x2Tensor: Tensor; + let yTensor: Tensor; + let concatOperation: Concat3D; + let tensorArrayMap: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + tensorArrayMap = new TensorArrayMap(); + }); + + afterEach(() => { + tensorArrayMap.disposeArray(x1Tensor); + tensorArrayMap.disposeArray(x2Tensor); + tensorArrayMap.disposeArray(yTensor); + }); + + it('concats tensors, axis=0', () => { + const axis = 0; + + const x1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const x2 = Array3D.new([1, 1, 3], [4, 5, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor( + concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis)); + + tensorArrayMap.set(x1Tensor, x1); + tensorArrayMap.set(x2Tensor, x2); + + concatOperation = new Concat3D(x1Tensor, x2Tensor, axis, yTensor); + + concatOperation.feedForward(math, tensorArrayMap); + + const y = tensorArrayMap.get(yTensor); + + expect(y.shape).toEqual([2, 1, 3]); + expect(y.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('concats tensors, axis=1', () => { + const axis = 1; + + const x1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const x2 = Array3D.new([1, 1, 3], [4, 5, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor( + concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis)); + + tensorArrayMap.set(x1Tensor, x1); + tensorArrayMap.set(x2Tensor, x2); + + concatOperation = new Concat3D(x1Tensor, x2Tensor, axis, yTensor); + + concatOperation.feedForward(math, tensorArrayMap); + + const y = tensorArrayMap.get(yTensor); + + expect(y.shape).toEqual([1, 2, 3]); + expect(y.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); + + it('concats tensors, axis=2', () => { + const axis = 2; + + const x1 = Array3D.new([1, 1, 3], [1, 2, 3]); + const x2 = Array3D.new([1, 1, 3], [4, 5, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor( + concat3d_util.computeConcat3DOutputShape(x1.shape, x2.shape, axis)); + + tensorArrayMap.set(x1Tensor, x1); + tensorArrayMap.set(x2Tensor, x2); + + concatOperation = new Concat3D(x1Tensor, x2Tensor, axis, yTensor); + + concatOperation.feedForward(math, tensorArrayMap); + + const y = tensorArrayMap.get(yTensor); + + expect(y.shape).toEqual([1, 1, 6]); + expect(y.getValues()).toEqual(new Float32Array([1, 2, 3, 4, 5, 6])); + }); +}); \ No newline at end of file diff --git a/src/ops/convolution.ts b/src/ops/convolution.ts new file mode 100644 index 0000000000..a3f3ffa955 --- /dev/null +++ b/src/ops/convolution.ts @@ -0,0 +1,100 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as conv_util from '../math/conv_util'; +import {MatrixOrientation, NDArrayMath} from '../math/math'; +import {Array1D, Array2D, Array3D, Array4D, NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Convolution2D extends Operation { + private zeroPad: number; + + /** + * Constructs a convolution op with the specified properties. + * + * @param inputShape The shape of the input ndarray. + * @param fieldSize The size of the filter (rows/cols of sliding window). + * @param outputDepth The depth of the output (Number of filters). + * @param stride How many pixels to shift the filter by when sliding. + * Defaults to 1. + * @param zeroPad How many pixels to pad the input from each side. Defaults to + * a value so that the rows and columns of the output ndarray is + * the same as the input ndarray. + * @param weights Optional. The weights of the filters. + * @param biases Optional. The bias terms of the filters. + */ + constructor( + private wTensor: Tensor, private xTensor: Tensor, private bTensor: Tensor, + private yTensor: Tensor, private fieldSize: number, + private outputDepth: number, private stride = 1, zeroPad?: number) { + super(); + this.assertWeightsShape(wTensor.shape); + this.zeroPad = zeroPad != null ? + zeroPad : + conv_util.computeDefaultPad( + this.xTensor.shape as [number, number, number], this.fieldSize, + this.stride); + util.assert( + util.isInt(this.zeroPad), + `The zero padding (${this.zeroPad}) must be an integer. Change the ` + + `stride and/or zero pad parameters`); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const weights = inferenceArrays.get(this.wTensor) as Array4D; + const biases = inferenceArrays.get(this.bTensor) as Array1D; + const x = inferenceArrays.get(this.xTensor) as Array3D; + + math.scope((keep) => { + inferenceArrays.set( + this.yTensor, + keep(math.conv2d(x, weights, biases, this.stride, this.zeroPad))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const weights = inferenceArrays.get(this.wTensor) as Array4D; + const x = inferenceArrays.get(this.xTensor) as Array3D; + const dy = gradientArrays.get(this.yTensor) as Array3D; + + math.scope((keep) => { + const {dw, db, dx} = + math.conv2dBackProp(x, dy, weights, this.stride, this.zeroPad); + gradientArrays.set(this.wTensor, keep(dw)); + gradientArrays.set(this.bTensor, keep(db)); + gradientArrays.set(this.xTensor, keep(dx)); + }); + } + + private assertWeightsShape(weightsShape: number[]) { + util.assert( + weightsShape[0] === this.fieldSize && + weightsShape[1] === this.fieldSize && + weightsShape[2] === this.xTensor.shape[2] && + weightsShape[3] === this.outputDepth, + `weights must be of shape [${this.fieldSize},${this.fieldSize},` + + `${this.xTensor.shape[2]},${this.outputDepth}] but they are of` + + `shape [${weightsShape}]`); + } +} diff --git a/src/ops/convolution_test.ts b/src/ops/convolution_test.ts new file mode 100644 index 0000000000..671c93cf17 --- /dev/null +++ b/src/ops/convolution_test.ts @@ -0,0 +1,352 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as conv_util from '../math/conv_util'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Array3D, Array4D, NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as test_util from '../test_util'; + +import {Convolution2D} from './convolution'; + +function assertNoNaNs(t: NDArray) { + const values = t.getValues(); + for (let i = 0; i < values.length; ++i) { + expect(isNaN(values[i])).toBe(false); + } +} + +describe('Convolution', () => { + let math: NDArrayMathCPU; + let wTensor: Tensor; + let xTensor: Tensor; + let bTensor: Tensor; + let yTensor: Tensor; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(wTensor); + activations.disposeArray(xTensor); + activations.disposeArray(bTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(wTensor); + gradients.disposeArray(xTensor); + gradients.disposeArray(bTensor); + gradients.disposeArray(yTensor); + }); + + it('Forward prop comparison with convnetjs', () => { + const inputDepth = 3; + const outputDepth = 2; + const fieldSize = 3; + const stride = 2; + const zeroPad = 1; + const weights2D = + Array2D.new([fieldSize * fieldSize * inputDepth, outputDepth], [ + 1, -1, 1, 0, -1, 1, -1, 0, -1, 0, 0, 1, -1, 1, 1, 1, 1, 1, + 0, 1, 0, 0, 0, 1, -1, -1, 1, 0, 1, -1, 1, 1, 1, 1, 1, -1, + -1, 0, 1, 0, 0, 0, 1, -1, -1, -1, 1, 0, -1, 1, 0, -1, 0, 1 + ]); + + const weights = + weights2D.as4D(fieldSize, fieldSize, inputDepth, outputDepth); + const biases = Array1D.new([1, 0]); + const x2D = Array2D.new([25, inputDepth], [ + 1, 2, 2, 0, 0, 2, 2, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 0, + 2, 2, 1, 1, 0, 0, 2, 1, 1, 0, 1, 2, 2, 0, 0, 2, 2, 1, 2, + 2, 2, 1, 2, 2, 2, 1, 1, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 1, + 0, 1, 2, 0, 0, 0, 0, 1, 0, 0, 2, 2, 1, 0, 2, 0, 0, 0 + ]); + const x = x2D.as3D(5, 5, inputDepth); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fieldSize, outputDepth, stride, zeroPad)); + + activations.set(wTensor, weights); + activations.set(xTensor, x); + activations.set(bTensor, biases); + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fieldSize, outputDepth, stride, + zeroPad); + conv.feedForward(math, activations); + + const result = activations.get(yTensor); + + expect(result.getValues()).toEqual(new Float32Array([ + 7, -8, 8, -2, 7, -2, 5, 5, 4, 6, 1, 2, -1, 3, 7, -2, 1, 4 + ])); + }); + + it('Maintains the rows and cols of input', () => { + const inputDepth = 3; + const outputDepth = 2; + const fSize = 3; + const stride = 1; + + const weights = + NDArray.randNormal([fSize, fSize, inputDepth, outputDepth]); + const biases = NDArray.randNormal([outputDepth]); + const x = NDArray.randNormal([5, 5, inputDepth]); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor( + conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride)); + + activations.set(wTensor, weights); + activations.set(xTensor, x); + activations.set(bTensor, biases); + + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fSize, outputDepth, stride); + + conv.feedForward(math, activations); + + const result = activations.get(yTensor); + + expect(result.shape).toEqual([5, 5, outputDepth]); + }); + + it('Can not maintain the rows and cols of input', () => { + const inputDepth = 3; + const outputDepth = 2; + const fSize = 2; + const stride = 1; + + const weights = + NDArray.randNormal([fSize, fSize, inputDepth, outputDepth]); + const biases = NDArray.randNormal([outputDepth]); + const x = NDArray.randNormal([5, 5, inputDepth]); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor( + conv_util.computeOutputShape3D(x.shape, fSize, outputDepth, stride)); + + activations.set(wTensor, weights); + activations.set(xTensor, x); + activations.set(bTensor, biases); + + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fSize, outputDepth, stride); + + conv.feedForward(math, activations); + + const result = activations.get(yTensor); + + expect(result.shape).toEqual([4, 4, outputDepth]); + }); + + it('Large convolution', () => { + const inputDepth = 3; + const fSize = 7; + const outputDepth = 10; + const stride = 1; + const zeroPad = 1; + + const weights = + NDArray.randNormal([fSize, fSize, inputDepth, outputDepth]); + const biases = NDArray.randNormal([outputDepth]); + const x = NDArray.randNormal([30, 30, inputDepth]); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, outputDepth, stride, zeroPad)); + + activations.set(wTensor, weights); + activations.set(xTensor, x); + activations.set(bTensor, biases); + + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fSize, outputDepth, stride, + zeroPad); + + conv.feedForward(math, activations); + + const result = activations.get(yTensor); + + assertNoNaNs(result); + expect(result.shape).toEqual([26, 26, outputDepth]); + }); + + it('simple conv backprop with d1=d2=1 (input and output)', () => { + // 3X3 image convolved with a 2x2 filter with no padding and stride 1. + // To keep the test simple, we work with input and output depth of 1. + const inputDepth = 1; + const fSize = 2; + const outputDepth = 1; + const stride = 1; + const zeroPad = 0; + + const x3d = NDArray.randNormal([3, 3, inputDepth]); + const x = x3d.as2D(3, 3); + const weights = + NDArray.randNormal([fSize, fSize, inputDepth, outputDepth]); + const biases = NDArray.randNormal([outputDepth]); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x3d.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x3d.shape, fSize, outputDepth, stride, zeroPad)); + + activations.set(wTensor, weights); + activations.set(xTensor, x3d); + activations.set(bTensor, biases); + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fSize, outputDepth, stride, + zeroPad); + + conv.feedForward(math, activations); + + const y = activations.get(yTensor); + + assertNoNaNs(y); + + expect(y.get(0, 0, 0)) + .toBeCloseTo( + x.get(0, 0) * weights.get(0, 0, 0, 0) + + x.get(0, 1) * weights.get(0, 1, 0, 0) + + x.get(1, 0) * weights.get(1, 0, 0, 0) + + x.get(1, 1) * weights.get(1, 1, 0, 0) + biases.get(0)); + + expect(y.get(0, 1, 0)) + .toBeCloseTo( + x.get(0, 1) * weights.get(0, 0, 0, 0) + + x.get(0, 2) * weights.get(0, 1, 0, 0) + + x.get(1, 1) * weights.get(1, 0, 0, 0) + + x.get(1, 2) * weights.get(1, 1, 0, 0) + biases.get(0)); + + expect(y.get(1, 0, 0)) + .toBeCloseTo( + x.get(1, 0) * weights.get(0, 0, 0, 0) + + x.get(1, 1) * weights.get(0, 1, 0, 0) + + x.get(2, 0) * weights.get(1, 0, 0, 0) + + x.get(2, 1) * weights.get(1, 1, 0, 0) + biases.get(0)); + + expect(y.get(1, 1, 0)) + .toBeCloseTo( + x.get(1, 1) * weights.get(0, 0, 0, 0) + + x.get(1, 2) * weights.get(0, 1, 0, 0) + + x.get(2, 1) * weights.get(1, 0, 0, 0) + + x.get(2, 2) * weights.get(1, 1, 0, 0) + biases.get(0)); + + const dy3d = NDArray.randNormal([2, 2, 1]); + + gradients.set(yTensor, dy3d); + + conv.backProp(math, activations, gradients); + + const dx3d = gradients.get(xTensor); + + // Since depth (last dim) is 1, we reduce indexing by converting 3D -> 2D. + const dx = dx3d.as2D(3, 3); + const dy = dy3d.as2D(2, 2); + + // Test dX. + expect(dx.get(0, 0)).toBeCloseTo(dy.get(0, 0) * weights.get(0, 0, 0, 0)); + expect(dx.get(0, 1)) + .toBeCloseTo( + dy.get(0, 0) * weights.get(0, 1, 0, 0) + + dy.get(0, 1) * weights.get(0, 0, 0, 0)); + expect(dx.get(0, 2)).toBeCloseTo(dy.get(0, 1) * weights.get(0, 1, 0, 0)); + expect(dx.get(1, 1)) + .toBeCloseTo( + dy.get(0, 0) * weights.get(1, 1, 0, 0) + + dy.get(0, 1) * weights.get(1, 0, 0, 0) + + dy.get(1, 0) * weights.get(0, 1, 0, 0) + + dy.get(1, 1) * weights.get(0, 0, 0, 0)); + expect(dx.get(2, 1)) + .toBeCloseTo( + dy.get(1, 0) * weights.get(1, 1, 0, 0) + + dy.get(1, 1) * weights.get(1, 0, 0, 0)); + + + // Test dW. + const dw = gradients.get(wTensor); + + expect(dw.get(0, 0, 0, 0)) + .toBeCloseTo( + dy.get(0, 0) * x.get(0, 0) + dy.get(0, 1) * x.get(0, 1) + + dy.get(1, 0) * x.get(1, 0) + dy.get(1, 1) * x.get(1, 1)); + expect(dw.get(1, 1, 0, 0)) + .toBeCloseTo( + dy.get(0, 0) * x.get(1, 1) + dy.get(0, 1) * x.get(1, 2) + + dy.get(1, 0) * x.get(2, 1) + dy.get(1, 1) * x.get(2, 2)); + + // Test db (bias). + const db = gradients.get(bTensor).get(0); + + expect(db).toBeCloseTo( + dy.get(0, 0) + dy.get(0, 1) + dy.get(1, 0) + dy.get(1, 1)); + }); + + it('conv backprop with d1=3 d2=7', () => { + const fSize = 5; + const inputDepth = 3; + const outputDepth = 7; + const stride = 1; + const zeroPad = 1; + + const weights = + NDArray.randNormal([fSize, fSize, inputDepth, outputDepth]); + const biases = NDArray.randNormal([outputDepth]); + const x = NDArray.randNormal([10, 10, inputDepth]); + + wTensor = new Tensor(weights.shape); + xTensor = new Tensor(x.shape); + bTensor = new Tensor(biases.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, outputDepth, stride, zeroPad)); + + activations.set(wTensor, weights); + activations.set(xTensor, x); + activations.set(bTensor, biases); + + const conv = new Convolution2D( + wTensor, xTensor, bTensor, yTensor, fSize, outputDepth, stride, + zeroPad); + + conv.feedForward(math, activations); + + const result = activations.get(yTensor); + + assertNoNaNs(result); + + const dy = NDArray.randNormal(result.shape); + + gradients.set(yTensor, dy); + + conv.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + assertNoNaNs(dx); + }); +}); diff --git a/src/ops/divide.ts b/src/ops/divide.ts new file mode 100644 index 0000000000..c07dae7bc5 --- /dev/null +++ b/src/ops/divide.ts @@ -0,0 +1,114 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Divide extends Operation { + private ones: NDArray; + + /** + * Element-wise divide operation. Broadcasts if one of the tensors is + * scalar. + */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private yTensor: Tensor) { + super(); + util.assert( + util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), + 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const t1 = inferenceArrays.get(this.x1Tensor); + const t2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + let result: NDArray; + if (util.isScalarShape(t1.shape)) { + result = math.scalarDividedByArray(t1, t2); + } else if (util.isScalarShape(t2.shape)) { + result = math.arrayDividedByScalar(t1, t2); + } else { + result = math.divide(t1, t2); + } + inferenceArrays.set(this.yTensor, keep(result)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + const dy = gradientArrays.get(this.yTensor); + + const x1IsScalar = util.isScalarShape(x1.shape); + const x2IsScalar = util.isScalarShape(x2.shape); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.x1Tensor)) { + if (x1IsScalar) { + const div = math.divide(dy, x2); + + gradientArrays.set(this.x1Tensor, keep(math.sum(div))); + + div.dispose(); + } else if (x2IsScalar) { + gradientArrays.set( + this.x1Tensor, keep(math.arrayDividedByScalar(dy, x2))); + } else { + gradientArrays.set(this.x1Tensor, keep(math.divide(dy, x2))); + } + } + + if (graph_util.shouldBackProp(this.x2Tensor)) { + // dx2 = -1 * x1 * x2 ^ -2. + const x2Squared = math.elementWiseMul(x2, x2); + + let x1OverX2Squared: NDArray; + if (x2IsScalar) { + x1OverX2Squared = math.arrayDividedByScalar(x1, x2Squared); + } else if (x1IsScalar) { + x1OverX2Squared = math.scalarDividedByArray(x1, x2Squared); + } else { + x1OverX2Squared = math.divide(x1, x2Squared); + } + + const dx2 = math.neg(x1OverX2Squared); + const dyTimesDerivative = math.elementWiseMul(dy, dx2); + + if (x2IsScalar) { + gradientArrays.set(this.x2Tensor, keep(math.sum(dyTimesDerivative))); + } else { + gradientArrays.set(this.x2Tensor, keep(dyTimesDerivative)); + } + } + }); + } +} diff --git a/src/ops/divide_test.ts b/src/ops/divide_test.ts new file mode 100644 index 0000000000..411bd73de6 --- /dev/null +++ b/src/ops/divide_test.ts @@ -0,0 +1,158 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Divide} from './divide'; + +describe('divide operation', () => { + let math: NDArrayMathCPU; + + let x1Tensor: Tensor; + let x2Tensor: Tensor; + let yTensor: Tensor; + let divideOp: Divide; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(x1Tensor); + activations.disposeArray(x2Tensor); + activations.disposeArray(yTensor); + gradients.disposeArray(x1Tensor); + gradients.disposeArray(x2Tensor); + gradients.disposeArray(yTensor); + }); + + it('element wise divide', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array1D.new([2, 4, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + divideOp = new Divide(x1Tensor, x2Tensor, yTensor); + divideOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toBeCloseTo(1 / 2); + expect(y.get(1)).toBeCloseTo(2 / 4); + expect(y.get(2)).toBeCloseTo(3 / 6); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + divideOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor); + expect(dx1.get(0)).toBeCloseTo(dy.get(0) / x2.get(0)); + expect(dx1.get(1)).toBeCloseTo(dy.get(1) / x2.get(1)); + expect(dx1.get(2)).toBeCloseTo(dy.get(2) / x2.get(2)); + + const dx2 = gradients.get(x2Tensor); + expect(dx2.get(0)) + .toBeCloseTo(-1 * x1.get(0) * dy.get(0) * Math.pow(x2.get(0), -2)); + expect(dx2.get(1)) + .toBeCloseTo(-1 * x1.get(1) * dy.get(1) * Math.pow(x2.get(1), -2)); + expect(dx2.get(2)) + .toBeCloseTo(-1 * x1.get(2) * dy.get(2) * Math.pow(x2.get(2), -2)); + }); + + it('scalar divided by ndarray', () => { + const x1 = Scalar.new(2); + const x2 = Array1D.new([2, 4, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + divideOp = new Divide(x1Tensor, x2Tensor, yTensor); + divideOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toBeCloseTo(2 / 2); + expect(y.get(1)).toBeCloseTo(2 / 4); + expect(y.get(2)).toBeCloseTo(2 / 6); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + divideOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor).asScalar(); + expect(dx1.get()).toBeCloseTo( + dy.get(0) / x2.get(0) + dy.get(1) / x2.get(1) + dy.get(2) / x2.get(2)); + + const dx2 = gradients.get(x2Tensor); + expect(dx2.get(0)) + .toBeCloseTo(-1 * x1.get() * dy.get(0) * Math.pow(x2.get(0), -2)); + expect(dx2.get(1)) + .toBeCloseTo(-1 * x1.get() * dy.get(1) * Math.pow(x2.get(1), -2)); + expect(dx2.get(2)) + .toBeCloseTo(-1 * x1.get() * dy.get(2) * Math.pow(x2.get(2), -2)); + }); + + it('ndarray divided by scalar', () => { + const x1 = Array1D.new([2, 4, 6]); + const x2 = Scalar.new(2); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + divideOp = new Divide(x1Tensor, x2Tensor, yTensor); + divideOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toBeCloseTo(2 / 2); + expect(y.get(1)).toBeCloseTo(4 / 2); + expect(y.get(2)).toBeCloseTo(6 / 2); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + divideOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor); + expect(dx1.get(0)).toBeCloseTo(dy.get(0) / x2.get()); + expect(dx1.get(1)).toBeCloseTo(dy.get(1) / x2.get()); + expect(dx1.get(2)).toBeCloseTo(dy.get(2) / x2.get()); + + const dx2 = gradients.get(x2Tensor).asScalar(); + expect(dx2.get()).toBeCloseTo( + -1 * x1.get(0) * dy.get(0) * Math.pow(x2.get(), -2) + + -1 * x1.get(1) * dy.get(1) * Math.pow(x2.get(), -2) + + -1 * x1.get(2) * dy.get(2) * Math.pow(x2.get(), -2)); + }); +}); \ No newline at end of file diff --git a/src/ops/element_wise_activation.ts b/src/ops/element_wise_activation.ts new file mode 100644 index 0000000000..bef181b040 --- /dev/null +++ b/src/ops/element_wise_activation.ts @@ -0,0 +1,93 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {ActivationFunction, ReLUFunc, SigmoidFunc, SquareFunc, TanHFunc} from '../math/activation_functions'; +import {NDArrayMath} from '../math/math'; +import {NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class ElementWiseActivation extends Operation { + constructor( + protected xTensor: Tensor, protected yTensor: Tensor, + private func: ActivationFunction) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor); + + math.scope((keep) => { + inferenceArrays.set(this.yTensor, keep(this.func.output(math, x))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + // dE/dx_i = sum_j dE/dy_j * dy_j/dx_i + // = dE/dy_i * dy_i/dx_i + const x = inferenceArrays.get(this.xTensor); + const y = inferenceArrays.get(this.yTensor); + const dy = gradientArrays.get(this.yTensor); + + math.scope((keep) => { + const dydx = this.func.der(math, x, y); + gradientArrays.set(this.xTensor, keep(math.elementWiseMul(dy, dydx))); + dydx.dispose(); + }); + } +} + +/** + * @hidden + */ +export class ReLU extends ElementWiseActivation { + constructor(xTensor: Tensor, yTensor: Tensor) { + super(xTensor, yTensor, new ReLUFunc()); + } +} + +/** + * @hidden + */ +export class TanH extends ElementWiseActivation { + constructor(xTensor: Tensor, yTensor: Tensor) { + super(xTensor, yTensor, new TanHFunc()); + } +} + +/** + * @hidden + */ +export class Sigmoid extends ElementWiseActivation { + constructor(xTensor: Tensor, yTensor: Tensor) { + super(xTensor, yTensor, new SigmoidFunc()); + } +} + +/** + * @hidden + */ +export class Square extends ElementWiseActivation { + constructor(xTensor: Tensor, yTensor: Tensor) { + super(xTensor, yTensor, new SquareFunc()); + } +} diff --git a/src/ops/element_wise_activation_test.ts b/src/ops/element_wise_activation_test.ts new file mode 100644 index 0000000000..887524f4b3 --- /dev/null +++ b/src/ops/element_wise_activation_test.ts @@ -0,0 +1,145 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import {ReLU, Sigmoid, Square, TanH} from './element_wise_activation'; + +describe('Element wise activation', () => { + let math: NDArrayMathCPU; + let xTensor: Tensor; + let yTensor: Tensor; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(xTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(xTensor); + gradients.disposeArray(yTensor); + }); + + it('ReLU', () => { + const x = Array2D.new([2, 3], [3, 0, -1, 2, 9, -5]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + activations.set(xTensor, x); + + const op = new ReLU(xTensor, yTensor); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.getValues()).toEqual(new Float32Array([3, 0, 0, 2, 9, 0])); + + // Backprop. + const dy = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + + expect(dx.getValues()).toEqual(new Float32Array([1, 0, 0, 4, 5, 0])); + }); + + it('TanH', () => { + const x = Array1D.new([3, 0, -3]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + activations.set(xTensor, x); + + const op = new TanH(xTensor, yTensor); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + + expect(y.get(0)).toBeCloseTo(0.99505475, 6); + expect(y.get(1)).toBeCloseTo(0, 6); + expect(y.get(2)).toBeCloseTo(-0.99505475, 6); + + // Backprop. + const dy = Array1D.new([2, 4, 3]); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + expect(dx.get(0)).toBeCloseTo(2 * (1 - 0.99505475 * 0.99505475), 6); + expect(dx.get(1)).toBeCloseTo(4, 6); + expect(dx.get(2)).toBeCloseTo(3 * (1 - 0.99505475 * 0.99505475), 6); + }); + + it('Sigmoid', () => { + const x = Array1D.new([3, 0, -3]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + activations.set(xTensor, x); + + const op = new Sigmoid(xTensor, yTensor); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toBeCloseTo(0.9525741268, 6); + expect(y.get(1)).toBeCloseTo(0.5, 6); + expect(y.get(2)).toBeCloseTo(0.0474258731, 6); + + // Backprop. + const dy = Array1D.new([2, 4, 3]); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + expect(dx.get(0)).toBeCloseTo(2 * 0.9525741268 * (1 - 0.9525741268), 6); + expect(dx.get(1)).toBeCloseTo(4 * 0.5 * 0.5, 6); + expect(dx.get(2)).toBeCloseTo(3 * 0.0474258731 * (1 - 0.0474258731), 6); + }); + + it('Square', () => { + const x = Array1D.new([2, 0, -3]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + activations.set(xTensor, x); + + const op = new Square(xTensor, yTensor); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.getValues()).toEqual(new Float32Array([4, 0, 9])); + + // Backprop. + const dy = Array1D.new([1, 2, 3]); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + expect(dx.get(0)).toBe(2 * x.get(0) * dy.get(0)); + expect(dx.get(1)).toBe(2 * x.get(1) * dy.get(1)); + expect(dx.get(2)).toBe(2 * x.get(2) * dy.get(2)); + }); +}); diff --git a/src/ops/element_wise_cost.ts b/src/ops/element_wise_cost.ts new file mode 100644 index 0000000000..e407822cd3 --- /dev/null +++ b/src/ops/element_wise_cost.ts @@ -0,0 +1,80 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {ElementWiseCostFunction, SquareCostFunc} from '../math/cost_functions'; +import {NDArrayMath} from '../math/math'; +import {Array1D, NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class ElementWiseCost extends Operation { + private oneOverNScalar: Scalar; + + constructor( + protected x1Tensor: Tensor, protected x2Tensor: Tensor, + protected yTensor: Tensor, protected func: ElementWiseCostFunction) { + super(); + this.oneOverNScalar = Scalar.new(1 / util.sizeFromShape(x1Tensor.shape)); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + const elementWiseCost = this.func.cost(math, x1, x2); + const sum = math.sum(elementWiseCost); + const result = math.scalarTimesArray(this.oneOverNScalar, sum); + inferenceArrays.set(this.yTensor, keep(result)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.x1Tensor)) { + gradientArrays.set(this.x1Tensor, keep(this.func.der(math, x1, x2))); + } + if (graph_util.shouldBackProp(this.x2Tensor)) { + gradientArrays.set(this.x2Tensor, keep(this.func.der(math, x2, x1))); + } + }); + } + + dispose() { + this.func.dispose(); + this.oneOverNScalar.dispose(); + } +} + +/** + * @hidden + */ +export class MeanSquaredCost extends ElementWiseCost { + constructor(x1Tensor: Tensor, x2Tensor: Tensor, yTensor: Tensor) { + super(x1Tensor, x2Tensor, yTensor, new SquareCostFunc()); + } +} diff --git a/src/ops/element_wise_cost_test.ts b/src/ops/element_wise_cost_test.ts new file mode 100644 index 0000000000..ae0aae777f --- /dev/null +++ b/src/ops/element_wise_cost_test.ts @@ -0,0 +1,73 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {MeanSquaredCost} from './element_wise_cost'; + +describe('MeanSquaredCost', () => { + let math: NDArrayMathCPU; + + let x1Tensor: Tensor; + let x2Tensor: Tensor; + let yTensor: Tensor; + let meanSquaredCostOperation: MeanSquaredCost; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(x1Tensor); + activations.disposeArray(x2Tensor); + activations.disposeArray(yTensor); + }); + + it('mean squared cost, forward & backward', () => { + const axis = 0; + + const x1 = Array1D.new([1, 2, 3, 4]); + const x2 = Array1D.new([2, 4, 6, 8]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor([]); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + meanSquaredCostOperation = new MeanSquaredCost(x1Tensor, x2Tensor, yTensor); + meanSquaredCostOperation.feedForward(math, activations); + meanSquaredCostOperation.backProp(math, activations, gradients); + + const y = activations.get(yTensor); + expect(y.shape).toEqual([]); + expect(y.getValues()).toEqual(new Float32Array([30 / 8])); + + const dx1 = gradients.get(x1Tensor); + const dx2 = gradients.get(x2Tensor); + expect(dx1.shape).toEqual(x1.shape); + expect(dx2.shape).toEqual(x2.shape); + expect(dx1.getValues()).toEqual(new Float32Array([-1, -2, -3, -4])); + expect(dx2.getValues()).toEqual(new Float32Array([1, 2, 3, 4])); + }); +}); \ No newline at end of file diff --git a/src/ops/exp.ts b/src/ops/exp.ts new file mode 100644 index 0000000000..8018dd7bd0 --- /dev/null +++ b/src/ops/exp.ts @@ -0,0 +1,56 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Exp extends Operation { + /** + * Exponentation operation - e^x. + */ + constructor(private xTensor: Tensor, private yTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor); + + math.scope((keep) => { + inferenceArrays.set(this.yTensor, keep(math.exp(x))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const y = inferenceArrays.get(this.yTensor); + const dy = gradientArrays.get(this.yTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.xTensor)) { + gradientArrays.set(this.xTensor, keep(math.elementWiseMul(y, dy))); + } + }); + } +} diff --git a/src/ops/exp_test.ts b/src/ops/exp_test.ts new file mode 100644 index 0000000000..a86dd92a53 --- /dev/null +++ b/src/ops/exp_test.ts @@ -0,0 +1,74 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Exp} from './exp'; + +describe('exp operation', () => { + let math: NDArrayMathCPU; + + let xTensor: Tensor; + let yTensor: Tensor; + let expOp: Exp; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(xTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(xTensor); + gradients.disposeArray(yTensor); + }); + + it('simple exp', () => { + const x = Array1D.new([1, 2, 3]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + + activations.set(xTensor, x); + + expOp = new Exp(xTensor, yTensor); + expOp.feedForward(math, activations); + const y = activations.get(yTensor); + + expect(y.shape).toEqual([3]); + expect(y.get(0)).toBeCloseTo(Math.exp(x.get(0))); + expect(y.get(1)).toBeCloseTo(Math.exp(x.get(1))); + expect(y.get(2)).toBeCloseTo(Math.exp(x.get(2))); + + const dy = Array1D.new([1, 2, 3]); + gradients.set(yTensor, dy); + + expOp.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + + expect(dx.shape).toEqual(dx.shape); + expect(dx.get(0)).toBeCloseTo(y.get(0) * dy.get(0)); + expect(dx.get(1)).toBeCloseTo(y.get(1) * dy.get(1)); + expect(dx.get(2)).toBeCloseTo(y.get(2) * dy.get(2)); + }); +}); \ No newline at end of file diff --git a/src/ops/linear_combination.ts b/src/ops/linear_combination.ts new file mode 100644 index 0000000000..82e5e40112 --- /dev/null +++ b/src/ops/linear_combination.ts @@ -0,0 +1,83 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class LinearCombination extends Operation { + /** + * A 2-tensor linear combination operation. + * + * Combines tensors x1 and x2 (of the same shape) with weights c1 & c2; + * Computes c1*x1 + c2*x2. + */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private c1Tensor: Tensor, private c2Tensor: Tensor, + private outTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + const c1 = inferenceArrays.get(this.c1Tensor).asScalar(); + const c2 = inferenceArrays.get(this.c2Tensor).asScalar(); + + math.scope((keep) => { + inferenceArrays.set( + this.outTensor, keep(math.scaledArrayAdd(c1, x1, c2, x2))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + const c1 = inferenceArrays.get(this.c1Tensor); + const c2 = inferenceArrays.get(this.c2Tensor); + const dy = gradientArrays.get(this.outTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.x1Tensor)) { + gradientArrays.set(this.x1Tensor, keep(math.scalarTimesArray(c1, dy))); + } + + if (graph_util.shouldBackProp(this.x2Tensor)) { + gradientArrays.set(this.x2Tensor, keep(math.scalarTimesArray(c2, dy))); + } + + if (graph_util.shouldBackProp(this.c1Tensor)) { + const dotProduct1 = math.elementWiseMul(x1, dy); + gradientArrays.set(this.c1Tensor, keep(math.sum(dotProduct1))); + } + + if (graph_util.shouldBackProp(this.c2Tensor)) { + const dotProduct2 = math.elementWiseMul(x2, dy); + gradientArrays.set(this.c2Tensor, keep(math.sum(dotProduct2))); + } + }); + } +} diff --git a/src/ops/linear_combination_test.ts b/src/ops/linear_combination_test.ts new file mode 100644 index 0000000000..a65e06dbf8 --- /dev/null +++ b/src/ops/linear_combination_test.ts @@ -0,0 +1,99 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import {LinearCombination} from './linear_combination'; + +describe('Linear combination', () => { + let math: NDArrayMathCPU; + let x1Tensor: Tensor; + let x2Tensor: Tensor; + let c1Tensor: Tensor; + let c2Tensor: Tensor; + let yTensor: Tensor; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(x1Tensor); + activations.disposeArray(x2Tensor); + activations.disposeArray(c1Tensor); + activations.disposeArray(c2Tensor); + activations.disposeArray(yTensor); + gradients.disposeArray(x1Tensor); + gradients.disposeArray(x2Tensor); + gradients.disposeArray(c1Tensor); + gradients.disposeArray(c2Tensor); + gradients.disposeArray(yTensor); + }); + + it('Simple linear combination', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array1D.new([10, 20, 30]); + const c1 = Scalar.new(3); + const c2 = Scalar.new(2); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + c1Tensor = new Tensor(c1.shape); + c2Tensor = new Tensor(c2.shape); + yTensor = new Tensor([]); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + activations.set(c1Tensor, c1); + activations.set(c2Tensor, c2); + + const op = + new LinearCombination(x1Tensor, x2Tensor, c1Tensor, c2Tensor, yTensor); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toBe(x1.get(0) * c1.get() + x2.get(0) * c2.get()); + expect(y.get(1)).toBe(x1.get(1) * c1.get() + x2.get(1) * c2.get()); + expect(y.get(2)).toBe(x1.get(2) * c1.get() + x2.get(2) * c2.get()); + + const dy = Array1D.new([2, 4, 6]); + gradients.set(yTensor, dy); + op.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor); + expect(dx1.get(0)).toBe(c1.get() * dy.get(0)); + expect(dx1.get(1)).toBe(c1.get() * dy.get(1)); + expect(dx1.get(2)).toBe(c1.get() * dy.get(2)); + + const dx2 = gradients.get(x2Tensor); + expect(dx2.get(0)).toBe(c2.get() * dy.get(0)); + expect(dx2.get(1)).toBe(c2.get() * dy.get(1)); + expect(dx2.get(2)).toBe(c2.get() * dy.get(2)); + + const dc1 = gradients.get(c1Tensor); + expect(dc1.get()).toBe( + x1.get(0) * dy.get(0) + x1.get(1) * dy.get(1) + x1.get(2) * dy.get(2)); + + const dc2 = gradients.get(c2Tensor); + expect(dc2.get()).toBe( + x2.get(0) * dy.get(0) + x2.get(1) * dy.get(1) + x2.get(2) * dy.get(2)); + }); +}); \ No newline at end of file diff --git a/src/ops/log.ts b/src/ops/log.ts new file mode 100644 index 0000000000..d79742cf2d --- /dev/null +++ b/src/ops/log.ts @@ -0,0 +1,56 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Log extends Operation { + /** + * Natural log operation - ln(x) + */ + constructor(private xTensor: Tensor, private yTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor); + + math.scope((keep) => { + inferenceArrays.set(this.yTensor, keep(math.log(x))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor); + const dy = gradientArrays.get(this.yTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.xTensor)) { + gradientArrays.set(this.xTensor, keep(math.divide(dy, x))); + } + }); + } +} diff --git a/src/ops/log_test.ts b/src/ops/log_test.ts new file mode 100644 index 0000000000..a83d1470b5 --- /dev/null +++ b/src/ops/log_test.ts @@ -0,0 +1,74 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Log} from './log'; + +describe('log operation', () => { + let math: NDArrayMathCPU; + + let xTensor: Tensor; + let yTensor: Tensor; + let logOp: Log; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(xTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(xTensor); + gradients.disposeArray(yTensor); + }); + + it('simple log', () => { + const x = Array1D.new([1, 2, 3]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(x.shape); + + activations.set(xTensor, x); + + logOp = new Log(xTensor, yTensor); + logOp.feedForward(math, activations); + const y = activations.get(yTensor); + + expect(y.shape).toEqual([3]); + expect(y.get(0)).toBeCloseTo(Math.log(x.get(0))); + expect(y.get(1)).toBeCloseTo(Math.log(x.get(1))); + expect(y.get(2)).toBeCloseTo(Math.log(x.get(2))); + + const dy = Array1D.new([1, 2, 3]); + gradients.set(yTensor, dy); + + logOp.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + + expect(dx.shape).toEqual(dx.shape); + expect(dx.get(0)).toBeCloseTo(dy.get(0) / x.get(0)); + expect(dx.get(1)).toBeCloseTo(dy.get(1) / x.get(1)); + expect(dx.get(2)).toBeCloseTo(dy.get(2) / x.get(2)); + }); +}); \ No newline at end of file diff --git a/src/ops/matmul.ts b/src/ops/matmul.ts new file mode 100644 index 0000000000..a86e2ddd00 --- /dev/null +++ b/src/ops/matmul.ts @@ -0,0 +1,93 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {MatrixOrientation, NDArrayMath} from '../math/math'; +import {Array1D, Array2D, NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class MatMul extends Operation { + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private yTensor: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + if (x1.shape.length === 2 && x2.shape.length === 2) { + inferenceArrays.set( + this.yTensor, keep(math.matMul(x1 as Array2D, x2 as Array2D))); + } else if (x1.shape.length === 2 && x2.shape.length === 1) { + inferenceArrays.set( + this.yTensor, + keep(math.matrixTimesVector(x1 as Array2D, x2 as Array1D))); + } else if (x1.shape.length === 1 && x2.shape.length === 2) { + inferenceArrays.set( + this.yTensor, + keep(math.vectorTimesMatrix(x1 as Array1D, x2 as Array2D))); + } + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + let x1 = inferenceArrays.get(this.x1Tensor); + let x2 = inferenceArrays.get(this.x2Tensor); + let dy = gradientArrays.get(this.yTensor); + + if (x1.shape.length === 1) { + x1 = x1.reshape([1, x1.size]); + dy = dy.reshape([1, dy.size]); + } + if (x2.shape.length === 1) { + x2 = x2.reshape([x2.size, 1]); + dy = dy.reshape([dy.size, 1]); + } + + math.scope((keep) => { + // y = x1 * x2 + // dx1 = dy * x2T + // dx2 = x1T * dy + if (graph_util.shouldBackProp(this.x1Tensor)) { + const dx1 = math.matMul( + dy as Array2D, x2 as Array2D, MatrixOrientation.REGULAR, + MatrixOrientation.TRANSPOSED); + gradientArrays.set( + this.x1Tensor, + keep(this.x1Tensor.shape.length === 1 ? dx1.as1D() : dx1)); + } + if (graph_util.shouldBackProp(this.x2Tensor)) { + const dx2 = math.matMul( + x1 as Array2D, dy as Array2D, MatrixOrientation.TRANSPOSED, + MatrixOrientation.REGULAR); + gradientArrays.set( + this.x2Tensor, + keep(this.x2Tensor.shape.length === 1 ? dx2.as1D() : dx2)); + } + }); + } +} diff --git a/src/ops/matmul_test.ts b/src/ops/matmul_test.ts new file mode 100644 index 0000000000..03acde0117 --- /dev/null +++ b/src/ops/matmul_test.ts @@ -0,0 +1,204 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {MatMul} from './matmul'; + +describe('add operation', () => { + let math: NDArrayMathCPU; + + let t1: Tensor; + let t2: Tensor; + let y: Tensor; + let matmulOp: MatMul; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(t1); + activations.disposeArray(t2); + activations.disposeArray(y); + gradients.disposeArray(t1); + gradients.disposeArray(t2); + gradients.disposeArray(y); + }); + + it('matmul two NDArray2Ds', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 10, 20, 30]); + const x2 = Array2D.new([3, 2], [2, 3, 4, 1, 2, 3]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor([x1.shape[0], x2.shape[1]]); + + activations.set(t1, x1); + activations.set(t2, x2); + + matmulOp = new MatMul(t1, t2, y); + matmulOp.feedForward(math, activations); + const yVal = activations.get(y) as Array2D; + + expect(yVal.shape).toEqual([x1.shape[0], x2.shape[1]]); + expect(yVal.get(0, 0)) + .toEqual( + x1.get(0, 0) * x2.get(0, 0) + x1.get(0, 1) * x2.get(1, 0) + + x1.get(0, 2) * x2.get(2, 0)); + expect(yVal.get(0, 1)) + .toEqual( + x1.get(0, 0) * x2.get(0, 1) + x1.get(0, 1) * x2.get(1, 1) + + x1.get(0, 2) * x2.get(2, 1)); + expect(yVal.get(1, 0)) + .toEqual( + x1.get(1, 0) * x2.get(0, 0) + x1.get(1, 1) * x2.get(1, 0) + + x1.get(1, 2) * x2.get(2, 0)); + expect(yVal.get(1, 1)) + .toEqual( + x1.get(1, 0) * x2.get(0, 1) + x1.get(1, 1) * x2.get(1, 1) + + x1.get(1, 2) * x2.get(2, 1)); + + const dy = Array2D.new([2, 2], [1, 2, 3, 4]); + gradients.set(y, dy); + + matmulOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1) as Array2D; + + // dx1 = dy * x2T + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.get(0, 0)) + .toEqual(dy.get(0, 0) * x2.get(0, 0) + dy.get(0, 1) * x2.get(0, 1)); + expect(dx1.get(0, 1)) + .toEqual(dy.get(0, 0) * x2.get(1, 0) + dy.get(0, 1) * x2.get(1, 1)); + expect(dx1.get(0, 2)) + .toEqual(dy.get(0, 0) * x2.get(2, 0) + dy.get(0, 1) * x2.get(2, 1)); + expect(dx1.get(1, 0)) + .toEqual(dy.get(1, 0) * x2.get(0, 0) + dy.get(1, 1) * x2.get(0, 1)); + expect(dx1.get(1, 1)) + .toEqual(dy.get(1, 0) * x2.get(1, 0) + dy.get(1, 1) * x2.get(1, 1)); + expect(dx1.get(1, 2)) + .toEqual(dy.get(1, 0) * x2.get(2, 0) + dy.get(1, 1) * x2.get(2, 1)); + + const dx2 = gradients.get(t2) as Array2D; + + // dx2 = x1T * dy + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.get(0, 0)) + .toEqual(x1.get(0, 0) * dy.get(0, 0) + x1.get(1, 0) * dy.get(1, 0)); + expect(dx2.get(0, 1)) + .toEqual(x1.get(0, 0) * dy.get(0, 1) + x1.get(1, 0) * dy.get(1, 1)); + expect(dx2.get(1, 0)) + .toEqual(x1.get(0, 1) * dy.get(0, 0) + x1.get(1, 1) * dy.get(1, 0)); + expect(dx2.get(1, 1)) + .toEqual(x1.get(0, 1) * dy.get(0, 1) + x1.get(1, 1) * dy.get(1, 1)); + expect(dx2.get(2, 0)) + .toEqual(x1.get(0, 2) * dy.get(0, 0) + x1.get(1, 2) * dy.get(1, 0)); + expect(dx2.get(2, 1)) + .toEqual(x1.get(0, 2) * dy.get(0, 1) + x1.get(1, 2) * dy.get(1, 1)); + }); + + it('matrix times vector', () => { + const inputSize = 3; + const outputSize = 2; + const x1 = Array2D.new([outputSize, inputSize], [1, 2, 0, 4, 3, 2]); + const x2 = Array1D.new([1, 2, 3]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor([x1.shape[0], x2.shape[1]]); + + activations.set(t1, x1); + activations.set(t2, x2); + + const op = new MatMul(t1, t2, y); + op.feedForward(math, activations); + + const yVal = activations.get(y); + expect(yVal.get(0)).toBe(5); + expect(yVal.get(1)).toBe(16); + + // Back prop. + const dy = Array1D.new([2, 3]); + gradients.set(y, dy); + + op.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1).as2D(x1.shape[0], x1.shape[1]); + expect(dx1.get(0, 0)).toBe(dy.get(0) * x2.get(0)); + expect(dx1.get(0, 1)).toBe(dy.get(0) * x2.get(1)); + expect(dx1.get(0, 2)).toBe(dy.get(0) * x2.get(2)); + expect(dx1.get(1, 0)).toBe(dy.get(1) * x2.get(0)); + expect(dx1.get(1, 1)).toBe(dy.get(1) * x2.get(1)); + expect(dx1.get(1, 2)).toBe(dy.get(1) * x2.get(2)); + + const dx2 = gradients.get(t2).as1D(); + expect(dx2.get(0)) + .toBe(x1.get(0, 0) * dy.get(0) + x1.get(1, 0) * dy.get(1)); + expect(dx2.get(1)) + .toBe(x1.get(0, 1) * dy.get(0) + x1.get(1, 1) * dy.get(1)); + expect(dx2.get(2)) + .toBe(x1.get(0, 2) * dy.get(0) + x1.get(1, 2) * dy.get(1)); + }); + + it('vector times matrix', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array2D.new([3, 2], [1, 2, 0, 4, 3, 2]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor([x1.shape[0], x2.shape[1]]); + + activations.set(t1, x1); + activations.set(t2, x2); + + const op = new MatMul(t1, t2, y); + op.feedForward(math, activations); + + const yVal = activations.get(y); + expect(yVal.get(0)).toBe(10); + expect(yVal.get(1)).toBe(16); + + // Back prop. + const dy = Array1D.new([2, 3]); + gradients.set(y, dy); + + op.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1).as1D(); + expect(dx1.get(0)) + .toBe(dy.get(0) * x2.get(0, 0) + dy.get(1) * x2.get(0, 1)); + expect(dx1.get(1)) + .toBe(dy.get(0) * x2.get(1, 0) + dy.get(1) * x2.get(1, 1)); + expect(dx1.get(2)) + .toBe(dy.get(0) * x2.get(2, 0) + dy.get(1) * x2.get(2, 1)); + + const dx2 = gradients.get(t2).as2D(x2.shape[0], x2.shape[1]); + expect(dx2.get(0, 0)).toBe(x1.get(0) * dy.get(0)); + expect(dx2.get(0, 1)).toBe(x1.get(0) * dy.get(1)); + expect(dx2.get(1, 0)).toBe(x1.get(1) * dy.get(0)); + expect(dx2.get(1, 1)).toBe(x1.get(1) * dy.get(1)); + expect(dx2.get(2, 0)).toBe(x1.get(2) * dy.get(0)); + expect(dx2.get(2, 1)).toBe(x1.get(2) * dy.get(1)); + }); +}); \ No newline at end of file diff --git a/src/ops/max_pool.ts b/src/ops/max_pool.ts new file mode 100644 index 0000000000..01ec8e6454 --- /dev/null +++ b/src/ops/max_pool.ts @@ -0,0 +1,72 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as conv_util from '../math/conv_util'; +import {NDArrayMath} from '../math/math'; +import {Array2D, Array3D, NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class MaxPool extends Operation { + private pad: number; + + constructor( + private xTensor: Tensor, private yTensor: Tensor, + private fieldSize: number, private stride = 1, pad?: number) { + super(); + + if (pad != null) { + this.pad = pad; + } else { + this.pad = conv_util.computeDefaultPad( + xTensor.shape as [number, number, number], this.fieldSize, + this.stride); + } + + util.assert( + util.isInt(this.pad), + `The zero padding (${this.pad}) must be an integer. Change the ` + + `stride and/or zero pad parameters`); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor) as Array3D; + math.scope((keep) => { + inferenceArrays.set( + this.yTensor, + keep(math.maxPool(x, this.fieldSize, this.stride, this.pad))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor) as Array3D; + const dy = gradientArrays.get(this.yTensor) as Array3D; + + math.scope((keep) => { + gradientArrays.set( + this.xTensor, + keep(math.maxPoolBackprop( + dy, x, this.fieldSize, this.stride, this.pad))); + }); + } +} diff --git a/src/ops/max_pool_test.ts b/src/ops/max_pool_test.ts new file mode 100644 index 0000000000..ac256c32db --- /dev/null +++ b/src/ops/max_pool_test.ts @@ -0,0 +1,158 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as conv_util from '../math/conv_util'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array3D, NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as test_util from '../test_util'; + +import {MaxPool} from './max_pool'; + + +describe('Max pool', () => { + let math: NDArrayMathCPU; + let xTensor: Tensor; + let yTensor: Tensor; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(xTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(xTensor); + gradients.disposeArray(yTensor); + }); + + it('Simple MaxPool', () => { + const fSize = 2; + const stride = 1; + const pad = 0; + const depth = 1; + + const x = Array3D.new([3, 3, depth], [1, 2, 3, 4, 5, 6, 7, 9, 8]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], stride, pad)); + + activations.set(xTensor, x); + + const op = new MaxPool(xTensor, yTensor, fSize, stride, pad); + + op.feedForward(math, activations); + + // Feed forward. + const y = activations.get(yTensor); + const expectedResult = Array3D.new([2, 2, depth], [5, 6, 9, 9]); + expect(expectedResult.equals(y)).toBe(true); + + // Backprop. + const dy = Array3D.new([2, 2, depth], [50, 60, 90, 80]); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dx = gradients.get(xTensor); + const expectedBackprop = + Array3D.new([3, 3, depth], [0, 0, 0, 0, 50, 60, 0, 170, 0]); + expect(expectedBackprop.equals(dx)).toBe(true); + }); + + it('MaxPool depth = 2', () => { + const fSize = 2; + const stride = 2; + const pad = 0; + const depth = 2; + + const x = Array3D.new([4, 4, depth], [ + 1, 11, 2, 22, 3, 33, 4, 44, 5, 55, 6, 66, 7, 77, 8, 88, + 9, 99, 10, 100, 11, 110, 12, 120, 13, 130, 14, 140, 15, 150, 16, 160 + ]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], stride, pad)); + + activations.set(xTensor, x); + + const op = new MaxPool(xTensor, yTensor, fSize, stride, pad); + + op.feedForward(math, activations); + + // Feed forward. + const y = activations.get(yTensor); + const expectedResult = + Array3D.new([2, 2, 2], [6, 66, 8, 88, 14, 140, 16, 160]); + test_util.expectArraysClose( + y.getValues(), expectedResult.getValues(), 1e-6); + }); + + it('MaxPool depth = 2, with some negative numbers', () => { + const fSize = 2; + const stride = 2; + const pad = 0; + const depth = 2; + + const x = Array3D.new([4, 4, 2], [ + -1, 11, 2, 22, 3, 33, 4, 44, 5, 55, 6, -66, 7, -77, 8, 88, + 9, 99, 10, 100, -11, 110, 12, 120, 13, 130, 14, 140, 15, 150, 16, -160 + ]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], stride, pad)); + + activations.set(xTensor, x); + + const op = new MaxPool(xTensor, yTensor, fSize, stride, pad); + op.feedForward(math, activations); + + // Feed forward. + const y = activations.get(yTensor); + const expectedResult = + Array3D.new([2, 2, 2], [6, 55, 8, 88, 14, 140, 16, 150]); + + test_util.expectArraysClose( + y.getValues(), expectedResult.getValues(), 1e-6); + }); + + it('MaxPool downsampling depth is preserved', () => { + const fSize = 2; + const stride = 2; + const pad = 0; + + const x = NDArray.randNormal([6, 6, 5]); + + xTensor = new Tensor(x.shape); + yTensor = new Tensor(conv_util.computeOutputShape3D( + x.shape, fSize, x.shape[2], stride, pad)); + + activations.set(xTensor, x); + + const op = new MaxPool(xTensor, yTensor, fSize, stride, pad); + op.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.shape).toEqual([3, 3, 5]); + }); +}); diff --git a/src/ops/multiply.ts b/src/ops/multiply.ts new file mode 100644 index 0000000000..1cb3229d5d --- /dev/null +++ b/src/ops/multiply.ts @@ -0,0 +1,99 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class Multiply extends Operation { + /** + * Element-wise multiply operation. Broadcasts if one of the tensors is + * scalar. + */ + constructor( + private x1Tensor: Tensor, private x2Tensor: Tensor, + private yTensor: Tensor) { + super(); + util.assert( + util.sizeFromShape(x1Tensor.shape) === 1 || + util.sizeFromShape(x2Tensor.shape) === 1 || + util.arraysEqual(x1Tensor.shape, x2Tensor.shape), + 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const t1 = inferenceArrays.get(this.x1Tensor); + const t2 = inferenceArrays.get(this.x2Tensor); + + math.scope((keep) => { + let result: NDArray; + if (util.isScalarShape(t1.shape)) { + result = math.scalarTimesArray(t1, t2); + } else if (util.isScalarShape(t2.shape)) { + result = math.scalarTimesArray(t2, t1); + } else { + result = math.elementWiseMul(t1, t2); + } + inferenceArrays.set(this.yTensor, keep(result)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const x1 = inferenceArrays.get(this.x1Tensor); + const x2 = inferenceArrays.get(this.x2Tensor); + const dy = gradientArrays.get(this.yTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.x1Tensor)) { + if (util.isScalarShape(this.x1Tensor.shape)) { + const mul = math.elementWiseMul(dy, x2); + + gradientArrays.set(this.x1Tensor, keep(math.sum(mul))); + + } else if (util.isScalarShape(x2.shape)) { + gradientArrays.set( + this.x1Tensor, keep(math.scalarTimesArray(x2, dy))); + } else { + gradientArrays.set(this.x1Tensor, keep(math.elementWiseMul(x2, dy))); + } + } + + if (graph_util.shouldBackProp(this.x2Tensor)) { + if (util.isScalarShape(this.x2Tensor.shape)) { + const mul = math.elementWiseMul(dy, x1); + + gradientArrays.set(this.x2Tensor, keep(math.sum(mul))); + + } else if (util.isScalarShape(x1.shape)) { + gradientArrays.set( + this.x2Tensor, keep(math.scalarTimesArray(x1, dy))); + } else { + gradientArrays.set(this.x2Tensor, keep(math.elementWiseMul(x1, dy))); + } + } + }); + } +} diff --git a/src/ops/multiply_test.ts b/src/ops/multiply_test.ts new file mode 100644 index 0000000000..4e0659634d --- /dev/null +++ b/src/ops/multiply_test.ts @@ -0,0 +1,150 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Multiply} from './multiply'; + +describe('divide operation', () => { + let math: NDArrayMathCPU; + + let x1Tensor: Tensor; + let x2Tensor: Tensor; + let yTensor: Tensor; + let multiplyOp: Multiply; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(x1Tensor); + activations.disposeArray(x2Tensor); + activations.disposeArray(yTensor); + gradients.disposeArray(x1Tensor); + gradients.disposeArray(x2Tensor); + gradients.disposeArray(yTensor); + }); + + it('element wise multiply', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array1D.new([2, 4, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + multiplyOp = new Multiply(x1Tensor, x2Tensor, yTensor); + multiplyOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toEqual(1 * 2); + expect(y.get(1)).toEqual(2 * 4); + expect(y.get(2)).toEqual(3 * 6); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + multiplyOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor); + expect(dx1.get(0)).toEqual(x2.get(0) * dy.get(0)); + expect(dx1.get(1)).toEqual(x2.get(1) * dy.get(1)); + expect(dx1.get(2)).toEqual(x2.get(2) * dy.get(2)); + + const dx2 = gradients.get(x2Tensor); + expect(dx2.get(0)).toEqual(x1.get(0) * dy.get(0)); + expect(dx2.get(1)).toEqual(x1.get(1) * dy.get(1)); + expect(dx2.get(2)).toEqual(x1.get(2) * dy.get(2)); + }); + + it('scalar times ndarray', () => { + const x1 = Scalar.new(2); + const x2 = Array1D.new([2, 4, 6]); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + multiplyOp = new Multiply(x1Tensor, x2Tensor, yTensor); + multiplyOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toEqual(2 * 2); + expect(y.get(1)).toEqual(2 * 4); + expect(y.get(2)).toEqual(2 * 6); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + multiplyOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor).asScalar(); + expect(dx1.get()).toEqual( + x2.get(0) * dy.get(0) + x2.get(1) * dy.get(1) + x2.get(2) * dy.get(2)); + + const dx2 = gradients.get(x2Tensor); + expect(dx2.get(0)).toEqual(x1.get() * dy.get(0)); + expect(dx2.get(1)).toEqual(x1.get() * dy.get(1)); + expect(dx2.get(2)).toEqual(x1.get() * dy.get(2)); + }); + + it('ndarray times scalar', () => { + const x1 = Array1D.new([2, 4, 6]); + const x2 = Scalar.new(2); + + x1Tensor = new Tensor(x1.shape); + x2Tensor = new Tensor(x2.shape); + yTensor = new Tensor(x2.shape); + + activations.set(x1Tensor, x1); + activations.set(x2Tensor, x2); + + multiplyOp = new Multiply(x1Tensor, x2Tensor, yTensor); + multiplyOp.feedForward(math, activations); + + const y = activations.get(yTensor); + expect(y.get(0)).toEqual(2 * 2); + expect(y.get(1)).toEqual(2 * 4); + expect(y.get(2)).toEqual(2 * 6); + + const dy = Array1D.new([3, 4, 5]); + gradients.set(yTensor, dy); + + multiplyOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(x1Tensor); + expect(dx1.get(0)).toEqual(x2.get() * dy.get(0)); + expect(dx1.get(1)).toEqual(x2.get() * dy.get(1)); + expect(dx1.get(2)).toEqual(x2.get() * dy.get(2)); + + const dx2 = gradients.get(x2Tensor).asScalar(); + expect(dx2.get()).toEqual( + x1.get(0) * dy.get(0) + x1.get(1) * dy.get(1) + x1.get(2) * dy.get(2)); + }); +}); \ No newline at end of file diff --git a/src/ops/op.ts b/src/ops/op.ts new file mode 100644 index 0000000000..74a467bbf6 --- /dev/null +++ b/src/ops/op.ts @@ -0,0 +1,35 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +/** + * @hidden + */ +export abstract class Operation { + abstract feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap): + void; + + abstract backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap): void; + + disposeTransientArrays( + inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) {} + + dispose() {} +} diff --git a/src/ops/reduce_sum.ts b/src/ops/reduce_sum.ts new file mode 100644 index 0000000000..6e7c4b840f --- /dev/null +++ b/src/ops/reduce_sum.ts @@ -0,0 +1,62 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * @hidden + */ +export class ReduceSum extends Operation { + /** Element-wise add operation. Broadcasts if one of the tensors is scalar. */ + constructor(private x: Tensor, private outTensor: Tensor) { + super(); + util.assertShapesMatch(outTensor.shape, []); + } + + private ones: NDArray; + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.x); + + math.scope((keep) => { + inferenceArrays.set(this.outTensor, keep(math.sum(x))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + if (!graph_util.shouldBackProp(this.x)) { + return; + } + + math.scope((keep) => { + const dy = gradientArrays.get(this.outTensor); + if (this.ones == null) { + const xArray = inferenceArrays.get(this.x); + this.ones = NDArray.zerosLike(xArray); + this.ones.fill(1); + } + gradientArrays.set(this.x, keep(math.scalarTimesArray(dy, this.ones))); + }); + } +} diff --git a/src/ops/reduce_sum_test.ts b/src/ops/reduce_sum_test.ts new file mode 100644 index 0000000000..75acdd75b9 --- /dev/null +++ b/src/ops/reduce_sum_test.ts @@ -0,0 +1,79 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {ReduceSum} from './reduce_sum'; + +describe('Reduce sum operation', () => { + let math: NDArrayMathCPU; + let reduceSumOp: ReduceSum; + let activations: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + }); + + afterEach(() => { + reduceSumOp.dispose(); + activations.dispose(); + }); + + it('Reduces a scalar', () => { + const xVal = Scalar.new(-3); + const x = new Tensor(xVal.shape); + const y = new Tensor([]); + + activations.set(x, xVal); + reduceSumOp = new ReduceSum(x, y); + reduceSumOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.get()).toBe(-3); + }); + + it('Reduces a 1-D tensor', () => { + const xVal = Array1D.new([1, 2, 3]); + const x = new Tensor(xVal.shape); + const y = new Tensor([]); + + activations.set(x, xVal); + reduceSumOp = new ReduceSum(x, y); + reduceSumOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.get()).toBe(6); + }); + + it('Reduces a 2-D tensor', () => { + const xVal = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x = new Tensor(xVal.shape); + const y = new Tensor([]); + + activations.set(x, xVal); + reduceSumOp = new ReduceSum(x, y); + reduceSumOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([]); + expect(yVal.get()).toBe(21); + }); +}); diff --git a/src/ops/reshape.ts b/src/ops/reshape.ts new file mode 100644 index 0000000000..1a90af7262 --- /dev/null +++ b/src/ops/reshape.ts @@ -0,0 +1,53 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMath} from '../math/math'; +import {NDArray} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +export class Reshape extends Operation { + constructor(private xTensor: Tensor, private yTensor: Tensor) { + super(); + const xSize = util.sizeFromShape(xTensor.shape); + const ySize = util.sizeFromShape(yTensor.shape); + util.assert( + xSize === ySize, + `The input size (${xSize}) and output size (${ySize}) must match`); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const x = inferenceArrays.get(this.xTensor) as T1; + + math.scope((keep) => { + inferenceArrays.set( + this.yTensor, keep(math.reshape(x, this.yTensor.shape))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const dy = gradientArrays.get(this.yTensor) as T2; + + math.scope((keep) => { + gradientArrays.set( + this.xTensor, keep(math.reshape(dy, this.xTensor.shape))); + }); + } +} diff --git a/src/ops/softmax.ts b/src/ops/softmax.ts new file mode 100644 index 0000000000..2997b9fb0c --- /dev/null +++ b/src/ops/softmax.ts @@ -0,0 +1,99 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMath} from '../math/math'; +import {Array1D, NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +export class Softmax extends Operation { + constructor(private logitsTensor: Tensor, private output: Tensor) { + super(); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const logits = inferenceArrays.get(this.logitsTensor) as Array1D; + return math.scope((keep) => { + inferenceArrays.set(this.output, keep(math.softmax(logits))); + }); + } + + backProp() { + throw Error('Softmax backprop is not yet implemented'); + } +} + +export class SoftmaxCrossEntropyCost extends Operation { + constructor( + private logitsTensor: Tensor, private labelTensor: Tensor, + private yTensor: Tensor) { + super(); + this.softmaxTensor = new Tensor(logitsTensor.shape); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const logits = inferenceArrays.get(this.logitsTensor) as Array1D; + const label = inferenceArrays.get(this.labelTensor) as Array1D; + + math.scope((keep) => { + const softmaxResult = math.softmax(logits); + + inferenceArrays.set(this.softmaxTensor, keep(softmaxResult)); + inferenceArrays.set( + this.yTensor, + keep(crossEntropyCost(math, softmaxResult, label, this.epsilon))); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const softmax = inferenceArrays.get(this.softmaxTensor); + const label = inferenceArrays.get(this.labelTensor); + + math.scope((keep) => { + gradientArrays.set(this.logitsTensor, keep(math.sub(softmax, label))); + }); + } + + disposeTransientArrays( + inferenceArrays: TensorArrayMap, gradientArrays: TensorArrayMap) { + inferenceArrays.disposeArray(this.softmaxTensor); + } + + dispose() { + this.epsilon.dispose(); + } + + private softmaxTensor: Tensor; + private epsilon = Scalar.new(1e-5); +} + +export function crossEntropyCost( + math: NDArrayMath, y: Array1D, target: Array1D, epsilon: Scalar): Scalar { + util.assert( + y.size === target.size, 'The output and target must be the same size'); + + return math.scope(() => { + const yPlusEps = math.scalarPlusArray(epsilon, y); + const logOutput = math.log(yPlusEps); + const tarLogOutput = math.elementWiseMul(target, logOutput); + const costVector = math.neg(tarLogOutput); + return math.sum(costVector); + }); +} diff --git a/src/ops/softmax_test.ts b/src/ops/softmax_test.ts new file mode 100644 index 0000000000..39975169e3 --- /dev/null +++ b/src/ops/softmax_test.ts @@ -0,0 +1,79 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {SoftmaxCrossEntropyCost} from './softmax'; + +describe('softmax cross entropy cost', () => { + let math: NDArrayMathCPU; + let logitsTensor: Tensor; + let labelTensor: Tensor; + let yTensor: Tensor; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(logitsTensor); + activations.disposeArray(yTensor); + gradients.disposeArray(logitsTensor); + gradients.disposeArray(yTensor); + }); + + it('matches theory', () => { + // Verify that when having softmax + cross entropy, + // dE/dx = y - t, which is the theoretical result. + const logits = Array1D.new([1, 2, 3]); + const label = Array1D.new([0.3, 0.6, 0.1]); + const softmaxLogits = math.softmax(logits); + + logitsTensor = new Tensor(logits.shape); + labelTensor = new Tensor(label.shape); + yTensor = new Tensor([]); + + activations.set(logitsTensor, logits); + activations.set(labelTensor, label); + + const op = new SoftmaxCrossEntropyCost(logitsTensor, labelTensor, yTensor); + + op.feedForward(math, activations); + const y = activations.get(yTensor); + + expect(y.get(0)).toBeCloseTo( + -Math.log(softmaxLogits.get(0)) * label.get(0) + + -Math.log(softmaxLogits.get(1)) * label.get(1) + + -Math.log(softmaxLogits.get(2)) * label.get(2), + 3); + + const dy = Scalar.new(1); + gradients.set(yTensor, dy); + + op.backProp(math, activations, gradients); + + const dLogits = gradients.get(logitsTensor); + expect(dLogits.get(0)).toBeCloseTo(softmaxLogits.get(0) - label.get(0), 6); + expect(dLogits.get(1)).toBeCloseTo(softmaxLogits.get(1) - label.get(1), 6); + expect(dLogits.get(2)).toBeCloseTo(softmaxLogits.get(2) - label.get(2), 6); + }); +}); diff --git a/src/ops/split.ts b/src/ops/split.ts new file mode 100644 index 0000000000..daa8738c02 --- /dev/null +++ b/src/ops/split.ts @@ -0,0 +1,62 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +/** + * Split ops are used to accumulate backprop derivatives when a node's output + * tensor is consumed by multiple nodes. + */ +export class Split extends Operation { + constructor(private input: Tensor, private outputs: Tensor[]) { + super(); + outputs.forEach(output => { + util.assertShapesMatch(input.shape, output.shape); + }); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const inputArray = inferenceArrays.get(this.input); + this.outputs.forEach(output => { + inferenceArrays.set(output, inputArray); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + if (!graph_util.shouldBackProp(this.input)) { + return; + } + + math.scope((keep) => { + let dx = math.add( + gradientArrays.get(this.outputs[0]), + gradientArrays.get(this.outputs[1])); + // Sum across all the derivatives of the consumers of this node. + this.outputs.slice(2).forEach(output => { + dx = math.add(dx, gradientArrays.get(output)); + }); + gradientArrays.set(this.input, keep(dx)); + }); + } +} diff --git a/src/ops/split_test.ts b/src/ops/split_test.ts new file mode 100644 index 0000000000..1ac3b81e43 --- /dev/null +++ b/src/ops/split_test.ts @@ -0,0 +1,76 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as test_util from '../test_util'; + +import {Split} from './split'; + +describe('Split operation', () => { + let math: NDArrayMathCPU; + + let splitOp: Split; + let tensorArrayMap: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + tensorArrayMap = new TensorArrayMap(); + }); + + afterEach(() => { + splitOp.dispose(); + tensorArrayMap.dispose(); + }); + + it('Forward prop split', () => { + const xVal = Scalar.new(-3); + const x = new Tensor(xVal.shape); + const y1 = new Tensor(x.shape); + const y2 = new Tensor(x.shape); + tensorArrayMap.set(x, xVal); + splitOp = new Split(x, [y1, y2]); + splitOp.feedForward(math, tensorArrayMap); + const y1Val = tensorArrayMap.get(y1); + const y2Val = tensorArrayMap.get(y2); + test_util.expectArraysClose(y1Val.getValues(), xVal.getValues(), 1e-5); + test_util.expectArraysClose(y2Val.getValues(), xVal.getValues(), 1e-5); + }); + + it('Forward+backward prop split', () => { + const xVal = Array1D.new([4, 5, -6]); + const x = new Tensor(xVal.shape); + const y1 = new Tensor(x.shape); + const y2 = new Tensor(x.shape); + tensorArrayMap.set(x, xVal); + splitOp = new Split(x, [y1, y2]); + splitOp.feedForward(math, tensorArrayMap); + const y1Val = tensorArrayMap.get(y1); + const y2Val = tensorArrayMap.get(y2); + test_util.expectArraysClose(y1Val.getValues(), xVal.getValues(), 1e-5); + test_util.expectArraysClose(y2Val.getValues(), xVal.getValues(), 1e-5); + + const gradientArrayMap = new TensorArrayMap(); + gradientArrayMap.set(y1, Array1D.new([-1, 4, 3])); + gradientArrayMap.set(y2, Array1D.new([-2, 2, -3])); + splitOp.backProp(math, tensorArrayMap, gradientArrayMap); + const dx = gradientArrayMap.get(x); + const expected = new Float32Array([-3, 6, 0]); + test_util.expectArraysClose(dx.getValues(), expected, 1e-5); + gradientArrayMap.dispose(); + }); +}); diff --git a/src/ops/subtract.ts b/src/ops/subtract.ts new file mode 100644 index 0000000000..b4bd7038ac --- /dev/null +++ b/src/ops/subtract.ts @@ -0,0 +1,102 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import * as graph_util from '../graph_util'; +import {NDArrayMath} from '../math/math'; +import {NDArray, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; +import * as util from '../util'; + +import {Operation} from './op'; + +export class Subtract extends Operation { + private dySizeScalar: Scalar; + + /** + * Element-wise subtract operation. Broadcasts if one of the tensors is + * scalar. + */ + constructor( + private t1: Tensor, private t2: Tensor, private outTensor: Tensor) { + super(); + util.assert( + util.sizeFromShape(t1.shape) === 1 || + util.sizeFromShape(t2.shape) === 1 || + util.arraysEqual(t1.shape, t2.shape), + 'One of t1 or t2 must be a scalar, or t1 and t2 must have ' + + 'the same shape'); + } + + feedForward(math: NDArrayMath, inferenceArrays: TensorArrayMap) { + const t1 = inferenceArrays.get(this.t1); + const t2 = inferenceArrays.get(this.t2); + + math.scope((keep) => { + let result: NDArray; + if (util.isScalarShape(t1.shape)) { + result = math.scalarMinusArray(t1, t2); + } else if (util.isScalarShape(t2.shape)) { + result = math.arrayMinusScalar(t1, t2); + } else { + result = math.sub(t1, t2); + } + inferenceArrays.set(this.outTensor, keep(result)); + }); + } + + backProp( + math: NDArrayMath, inferenceArrays: TensorArrayMap, + gradientArrays: TensorArrayMap) { + const t1 = inferenceArrays.get(this.t1); + const t2 = inferenceArrays.get(this.t2); + const dy = gradientArrays.get(this.outTensor); + + math.scope((keep) => { + if (graph_util.shouldBackProp(this.t1)) { + if (util.isScalarShape(this.t1.shape)) { + const sum = math.sum(dy); + if (this.dySizeScalar == null) { + this.dySizeScalar = Scalar.new(dy.size); + } + gradientArrays.set( + this.t1, keep(math.divide(sum, this.dySizeScalar))); + } else { + gradientArrays.set(this.t1, keep(dy)); + } + } + + if (graph_util.shouldBackProp(this.t2)) { + if (util.isScalarShape(this.t2.shape)) { + const sum = math.sum(dy); + const negSum = math.neg(sum); + if (this.dySizeScalar == null) { + this.dySizeScalar = Scalar.new(dy.size); + } + gradientArrays.set( + this.t2, keep(math.divide(negSum, this.dySizeScalar))); + } else { + gradientArrays.set(this.t2, keep(math.neg(dy))); + } + } + }); + } + + dispose() { + if (this.dySizeScalar != null) { + this.dySizeScalar.dispose(); + } + } +} diff --git a/src/ops/subtract_test.ts b/src/ops/subtract_test.ts new file mode 100644 index 0000000000..8852592b6f --- /dev/null +++ b/src/ops/subtract_test.ts @@ -0,0 +1,197 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from '../graph'; +import {NDArrayMathCPU} from '../math/math_cpu'; +import {Array1D, Array2D, Scalar} from '../math/ndarray'; +import {TensorArrayMap} from '../tensor_array_map'; + +import {Subtract} from './subtract'; + +describe('add operation', () => { + let math: NDArrayMathCPU; + + let t1: Tensor; + let t2: Tensor; + let y: Tensor; + let subOp: Subtract; + let activations: TensorArrayMap; + let gradients: TensorArrayMap; + + beforeEach(() => { + math = new NDArrayMathCPU(); + activations = new TensorArrayMap(); + gradients = new TensorArrayMap(); + }); + + afterEach(() => { + activations.disposeArray(t1); + activations.disposeArray(t2); + activations.disposeArray(y); + gradients.disposeArray(t1); + gradients.disposeArray(t2); + gradients.disposeArray(y); + }); + + it('subtracts two 1-D tensors', () => { + const x1 = Array1D.new([1, 2, 3]); + const x2 = Array1D.new([3, 0, 3]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + subOp = new Subtract(t1, t2, y); + subOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([3]); + expect(yVal.getValues()).toEqual(new Float32Array([-2, 2, 0])); + + const dy = Array1D.new([6, 7, 8]); + gradients.set(y, dy); + + subOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(new Float32Array([-6, -7, -8])); + }); + + it('subtracts two 2-D tensors', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Array2D.new([2, 3], [9, 8, 7, 6, 5, 4]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + subOp = new Subtract(t1, t2, y); + subOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([-8, -6, -4, -2, 0, 2])); + + const dy = Array2D.new([2, 3], [10, 11, 12, 13, 14, 15]); + gradients.set(y, dy); + + subOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(new Float32Array([ + -10, -11, -12, -13, -14, -15 + ])); + }); + + it('ndarray - scalar', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Scalar.new(2); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + subOp = new Subtract(t1, t2, y); + subOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([-1, 0, 1, 2, 3, 4])); + + const dy = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + gradients.set(y, dy); + + subOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.getValues()).toEqual(dy.getValues()); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.get()).toEqual(-7); + }); + + it('scalar - ndarray', () => { + const x1 = Scalar.new(2); + const x2 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + subOp = new Subtract(t1, t2, y); + subOp.feedForward(math, activations); + const yVal = activations.get(y); + + expect(yVal.shape).toEqual([2, 3]); + expect(yVal.getValues()).toEqual(new Float32Array([1, 0, -1, -2, -3, -4])); + + const dy = Array2D.new([2, 3], [2, 4, 6, 8, 10, 12]); + gradients.set(y, dy); + + subOp.backProp(math, activations, gradients); + + const dx1 = gradients.get(t1); + const dx2 = gradients.get(t2); + + expect(dx1.shape).toEqual(x1.shape); + expect(dx1.get()).toEqual(7); + + expect(dx2.shape).toEqual(x2.shape); + expect(dx2.getValues()).toEqual(new Float32Array([ + -2, -4, -6, -8, -10, -12 + ])); + }); + + it('throws when shapes of X1 and X2 do not match', () => { + const x1 = Array2D.new([2, 3], [1, 2, 3, 4, 5, 6]); + const x2 = Array2D.new([3, 2], [1, 2, 3, 4, 5, 6]); + + t1 = new Tensor(x1.shape); + t2 = new Tensor(x2.shape); + y = new Tensor(x1.shape); + + activations.set(t1, x1); + activations.set(t2, x2); + + expect(() => new Subtract(t1, t2, y)).toThrowError(); + }); +}); diff --git a/src/optimizer.ts b/src/optimizer.ts new file mode 100644 index 0000000000..e4cd9b19ad --- /dev/null +++ b/src/optimizer.ts @@ -0,0 +1,47 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Node, Tensor, VariableNode} from './graph'; +import {NDArrayMath} from './math/math'; +import {SessionRuntime} from './session'; +import {TensorArrayMap} from './tensor_array_map'; + +export abstract class Optimizer { + protected variableNodes: VariableNode[]; + protected specifiedVariableNodes: VariableNode[]|null; + + constructor(specifiedVariableList?: Node[]) { + if (specifiedVariableList != null) { + this.specifiedVariableNodes = specifiedVariableList as VariableNode[]; + } + } + + abstract beforeBatch( + math: NDArrayMath, batchSize: number, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, + gradientArrayMap: TensorArrayMap): void; + + abstract afterExample( + math: NDArrayMath, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, + gradientArrayMap: TensorArrayMap): void; + + abstract afterBatch( + math: NDArrayMath, batchSize: number, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, + gradientArrayMap: TensorArrayMap): void; + + abstract dispose(): void; +} diff --git a/src/priority_queue.ts b/src/priority_queue.ts new file mode 100644 index 0000000000..3f0839c2c4 --- /dev/null +++ b/src/priority_queue.ts @@ -0,0 +1,223 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +/** + * Default comparison function for the priority queue. + * @param a The first element to compare. + * @param b The second element to compare. + * @return "a > b" returns > 0. "a < b" returns < 0. "a === b" returns 0. + */ +export function defaultCompare(a: T, b: T): number { + if (a === b) { + return 0; + } else if (a < b) { + return -1; + } else { + return 1; + } +} + +/** + * A Comparator is a user-provided function that compares two T instances. The + * convention for defaultCompare is expected to be followed to maintain the + * binary min-heap integrity. + * @param a The first element to compare. + * @param b The second element to compare. + */ +export type Comparator = (a: T, b: T) => number; + +/** + * IndexObserver is a user-provided callback that informs the caller when an + * element in the priority queue's binary min-heap has been relocated. + * @param t The element that was relocated. + * @param newIndex The new location in the binary min-heap of the element. + */ +export type IndexObserver = (t: T, newIndex: number) => void; + +/** + * A priority queue, implemented in terms of a binary min-heap. Lower priority + * numbers are considered higher priority. + * enqueue, dequeue, and update are all O(log N) with respect to the number of + * elements in the queue. + */ +export class PriorityQueue { + private heap: T[] = []; + + /** + * @param comparator A function that compares two queue elements. + * @param indexObserver An optional callback raised when the priority queue + * changes the order of elements in its min-heap. Useful for tracking the + * positions of elements that need updating. + */ + constructor( + private comparator: Comparator, + private indexObserver?: IndexObserver) {} + + /** + * Add an element to the priority queue. + * @param t The element to enqueue. + */ + enqueue(t: T) { + this.heap.push(t); + this.onIndexChanged(t, this.heap.length - 1); + this.siftUp(this.heap.length - 1); + } + + /** + * Remove an element from the priority queue. + * @return The element in the priority queue with the highest priority + * (lowest numeric priority value). + */ + dequeue(): T { + if (this.empty()) { + throw new Error('dequeue called on empty priority queue.'); + } + const t = this.heap[0]; + this.swap(0, this.heap.length - 1); + this.heap.pop(); + this.siftDown(0); + return t; + } + + /** + * Updates an element at the specified index. This can be a full element + * replacement, or it can be an in-place update. The priority is assumed to be + * changed, and the internal storage is updated. This function is only useful + * if the storage index of the updated element is known; construct the + * PriorityQueue with an IndexObserver to track element locations. + * @param newT The new element to replace in the priority queue. + * @param index The index to insert the new element into. + */ + update(newT: T, index: number) { + /* If the element is at the very end of the heap, no sifting is necessary, + * it can be safely removed. */ + const last = (index === this.heap.length - 1); + if (!last) { + this.swap(index, this.heap.length - 1); + } + this.heap.pop(); + if (!last) { + /* The element at 'index' has been removed, and replaced with whatever was + * at the end of the heap. Since that element might have come from a + * different subtree (and not be a direct descendant of the node at + * 'index'), we might need to sift this new value up instead of down. Test + * both directions, and sift to wherever the node needs to go. + */ + if (this.siftUpIndex(index) !== -1) { + this.siftUp(index); + } else if (this.siftDownIndex(index) !== -1) { + this.siftDown(index); + } + } + this.enqueue(newT); + } + + /** + * Predicate for testing whether the PriorityQueue is empty. + * @return True if the PriorityQueue is empty, otherwise False. + */ + empty(): boolean { + return this.heap.length === 0; + } + + private onIndexChanged(t: T, newIndex: number) { + if (this.indexObserver) { + this.indexObserver(t, newIndex); + } + } + + /* + * Standard zero-indexed binary heap array layout: + * Parent(N) = Floor((N - 1) / 2) + * LeftChild(N) = (N * 2) + 1 + * RightChild(N) = (N * 2) + 2 + */ + + private getParentIndex(index: number): number { + if (index === 0) { + return -1; + } + return Math.floor((index - 1) / 2); + } + + private getLeftChildIndex(index: number): number { + const candidate = index * 2 + 1; + return candidate < this.heap.length ? candidate : -1; + } + + private getRightChildIndex(index: number): number { + const candidate = index * 2 + 2; + return candidate < this.heap.length ? candidate : -1; + } + + private siftUpIndex(index: number): number { + const parentIndex = this.getParentIndex(index); + if (parentIndex === -1) { + return -1; + } + if (this.compare(parentIndex, index) > 0) { + return parentIndex; + } + return -1; + } + + private siftUp(index: number) { + let siftIndex = this.siftUpIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftUpIndex(index); + } + } + + private siftDownIndex(index: number): number { + if (index >= this.heap.length) { + return -1; + } + let largestChildIndex = index; + const leftChildIndex = this.getLeftChildIndex(index); + if ((leftChildIndex !== -1) && + (this.compare(leftChildIndex, largestChildIndex) < 0)) { + largestChildIndex = leftChildIndex; + } + const rightChildIndex = this.getRightChildIndex(index); + if ((rightChildIndex !== -1) && + (this.compare(rightChildIndex, largestChildIndex) < 0)) { + largestChildIndex = rightChildIndex; + } + return (largestChildIndex === index) ? -1 : largestChildIndex; + } + + private siftDown(index: number) { + let siftIndex = this.siftDownIndex(index); + while (siftIndex !== -1) { + this.swap(index, siftIndex); + index = siftIndex; + siftIndex = this.siftDownIndex(index); + } + } + + private compare(aIndex: number, bIndex: number): number { + return this.comparator(this.heap[aIndex], this.heap[bIndex]); + } + + private swap(a: number, b: number) { + const temp = this.heap[a]; + this.heap[a] = this.heap[b]; + this.heap[b] = temp; + this.onIndexChanged(this.heap[a], a); + this.onIndexChanged(this.heap[b], b); + } +} diff --git a/src/priority_queue_test.ts b/src/priority_queue_test.ts new file mode 100644 index 0000000000..b6eb656cfe --- /dev/null +++ b/src/priority_queue_test.ts @@ -0,0 +1,199 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as priority_queue from './priority_queue'; +import {PriorityQueue} from './priority_queue'; + +describe('defaultCompare', () => { + it('returns 0 if a === b', () => { + expect(priority_queue.defaultCompare(123, 123)).toEqual(0); + }); + + it('returns 1 if a > b', () => { + expect(priority_queue.defaultCompare(1000, 999)).toEqual(1); + }); + + it('returns -1 if a < b', () => { + expect(priority_queue.defaultCompare(999, 1000)).toEqual(-1); + }); +}); + +describe('PriorityQueue', () => { + let pq: PriorityQueue; + + beforeEach(() => { + pq = new PriorityQueue(priority_queue.defaultCompare); + }); + + it('is empty by default', () => { + expect(pq.empty()).toEqual(true); + }); + + it('isn\'t empty after enqueue call', () => { + pq.enqueue(0); + expect(pq.empty()).toEqual(false); + }); + + it('returns to empty after dequeueing only element', () => { + pq.enqueue(0); + pq.dequeue(); + expect(pq.empty()).toEqual(true); + }); + + it('returns to empty after dequeueing last element', () => { + for (let i = 0; i < 10; ++i) { + pq.enqueue(i); + } + for (let i = 0; i < 9; ++i) { + pq.dequeue(); + expect(pq.empty()).toEqual(false); + } + pq.dequeue(); + expect(pq.empty()).toEqual(true); + }); + + it('dequeue throws when queue is empty', () => { + expect(() => pq.dequeue()) + .toThrow(new Error('dequeue called on empty priority queue.')); + }); + + it('dequeues the only enqueued item', () => { + pq.enqueue(1); + expect(pq.dequeue()).toEqual(1); + }); + + it('dequeues the lowest-priority of 2 items', () => { + pq.enqueue(1000); + pq.enqueue(0); + expect(pq.dequeue()).toEqual(0); + }); + + it('dequeues items in min-priority order', () => { + pq.enqueue(5); + pq.enqueue(8); + pq.enqueue(2); + pq.enqueue(9); + pq.enqueue(3); + pq.enqueue(7); + pq.enqueue(4); + pq.enqueue(0); + pq.enqueue(6); + pq.enqueue(1); + const dequeued: number[] = []; + while (!pq.empty()) { + dequeued.push(pq.dequeue()); + } + expect(dequeued).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + }); +}); + +describe('PriorityQueue index observer', () => { + let pq: PriorityQueue; + let indices: {[value: number]: number}; + + beforeEach(() => { + pq = new PriorityQueue( + priority_queue.defaultCompare, + (value: number, newIndex: number) => indices[value] = newIndex); + indices = {}; + }); + + it('notifies of new index when enqueuing', () => { + pq.enqueue(0); + expect(indices[0]).not.toBe(null); + }); + + it('puts first enqueued element at root of heap (index 0)', () => { + pq.enqueue(0); + expect(indices[0]).toEqual(0); + }); + + it('puts second greater element at left child of root (index 1)', () => { + pq.enqueue(0); + pq.enqueue(1); + expect(indices[0]).toEqual(0); + expect(indices[1]).toEqual(1); + }); + + it('puts third greater element at right child of root (index 2)', () => { + pq.enqueue(0); + pq.enqueue(1); + pq.enqueue(2); + expect(indices[0]).toEqual(0); + expect(indices[1]).toEqual(1); + expect(indices[2]).toEqual(2); + }); + + it('swaps root with new min enqueued element', () => { + pq.enqueue(1000); + pq.enqueue(0); + expect(indices[1000]).toEqual(1); + expect(indices[0]).toEqual(0); + }); +}); + +class TestEntry { + constructor(public id: number, public priority: number) {} +} + +describe('PriorityQueue.update', () => { + let pq: PriorityQueue; + let indices: {[id: number]: number}; + + beforeEach(() => { + pq = new PriorityQueue( + (a: TestEntry, b: TestEntry) => + priority_queue.defaultCompare(a.priority, b.priority), + (entry: TestEntry, newIndex: number) => indices[entry.id] = newIndex); + indices = {}; + }); + + it('no longer dequeues original min element after priority change', () => { + const e0 = new TestEntry(0, 10); + const e1 = new TestEntry(1, 100); + pq.enqueue(e0); + pq.enqueue(e1); + e0.priority = 101; + pq.update(e0, 0); + expect(pq.dequeue()).toBe(e1); + expect(pq.dequeue()).toBe(e0); + }); + + it('doesn\'t change index when priority doesn\'t change', () => { + const e = new TestEntry(0, 0); + pq.enqueue(e); + expect(indices[0]).toEqual(0); + pq.update(e, 0); + expect(indices[0]).toEqual(0); + }); + + it('doesn\'t change index when priority doesn\'t trigger sift', () => { + const e = new TestEntry(0, 0); + pq.enqueue(e); + expect(indices[0]).toEqual(0); + e.priority = 1234; + pq.update(e, 0); + expect(indices[0]).toEqual(0); + }); + + it('changes index when priority change triggers sift', () => { + const e = new TestEntry(0, 10); + pq.enqueue(e); + pq.enqueue(new TestEntry(1, 100)); + e.priority = 1000; + pq.update(e, 0); + expect(indices[0]).toEqual(1); + }); +}); diff --git a/src/session.ts b/src/session.ts new file mode 100644 index 0000000000..b40a39c114 --- /dev/null +++ b/src/session.ts @@ -0,0 +1,285 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Graph, Node, Tensor} from './graph'; +import * as graph_util from './graph_util'; +import {InputProvider} from './input_provider'; +import {NDArrayMath} from './math/math'; +import {NDArray, Scalar} from './math/ndarray'; +import * as operation_emitter from './operation_emitter'; +import {Operation} from './ops/op'; +import {Optimizer} from './optimizer'; +import * as session_util from './session_util'; +import {TensorArrayMap} from './tensor_array_map'; +import * as util from './util'; + +/** + * FeedEntry associates a tensor with user-provided NDArray data. + */ +export type FeedEntry = { + tensor: Tensor, + data: NDArray|InputProvider +}; + +/** + * A FeedDictionary holds a map from tensors to user-provided NDArrays. Feed + * dictionaries represent the 'entry points' of evaluation, since graph nodes + * that are replaced by feeds don't need to have their input nodes evaluated. + * Feed dictionaries usually provide NDArray data for Placeholder nodes, but any + * node in the graph can be replaced by a feed dictionary entry. + * + * @hidden + */ +export class FeedDictionary { + dict: {[tensorID: number]: FeedEntry} = {}; + + /** + * Optionally construct a FeedDictionary from an array of entries. + * @param feedEntries Optional array of FeedEntry objects. + */ + constructor(feedEntries?: FeedEntry[]) { + if (feedEntries) { + feedEntries.forEach(entry => this.dict[entry.tensor.id] = entry); + } + } +} + +export enum CostReduction { + NONE, + SUM, + MEAN +} + +/** + * A Session maintains the runtime state required to efficiently evaluate nodes. + * On their own, graph objects are very lightweight logical topologies; they + * have no relationship with the GPU. Sessions encapsulate the evaluation of + * nodes, the management of GPU resources, the caching of evaluation paths, and + * anything else required to evaluate or train a network. + */ +export class Session { + /** + * @param graph The graph to associate with this Session. + * @param math The NDArrayMath interface that this Session should use. + */ + constructor(private graph: Graph, private math: NDArrayMath) {} + + /** + * Release all system resources associated with this Session. + */ + dispose() { + this.activationArrayMap.dispose(); + Object.keys(this.runtimeCache).forEach(key => { + const runtime = this.runtimeCache[key]; + if (runtime.operations) { + runtime.operations.forEach(op => op.dispose()); + } + }); + this.runtimeCache = {}; + if (this.batchSizeScalar != null) { + this.batchSizeScalar.dispose(); + } + this.oneScalar.dispose(); + } + + /** + * Evaluate a list of tensors, using the provided feed entries to provide + * upstream NDArray input. + * When using a `NDArrayMath` object in safe mode this must be used in a + * math.scope(). + * @param tensors The list of tensors to evaluate. + * @param feedEntries List of `FeedEntry` to read when replacing graph + * tensors with NDArrays. + * @return The computed values of the tensors. + */ + evalAll(tensors: Tensor[], feedEntries: FeedEntry[]): NDArray[] { + return this.math.scope(() => { + const feed = new FeedDictionary(feedEntries); + const runtime = this.getOrCreateRuntime(tensors, feed); + + const activations = this.activationArrayMap; + + session_util.disposeAndInitializeOperationOutputs( + runtime.nodes, activations); + session_util.disposeTransientOperationArrays( + runtime.operations, this.activationArrayMap, this.gradientArrayMap); + + session_util.addPersistentArraysToTensorArrayMap( + runtime.nodes, activations); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap( + feed, activations, this.math); + + runtime.operations.forEach(op => op.feedForward(this.math, activations)); + + const results = tensors.map(x => activations.get(x)); + tensors.forEach(x => activations.delete(x)); + + session_util.releaseFeedDictionaryInputsFromTensorArrayMap( + feed, activations, this.math); + + return results; + }); + } + + /** + * Evaluate a tensor, using the provided feed entries to provide + * upstream NDArray input. + * + * @param tensor The tensor to evaluate. + * @param feedEntries List of `FeedEntry` to read when replacing graph + * tensors with NDArrays. + * @return The computed value of the tensor. + */ + eval(tensor: Tensor, feedEntries: FeedEntry[]): NDArray { + return this.evalAll([tensor], feedEntries)[0]; + } + + /** + * Trains a batch. + * Returns a reduced cost if the costReduction parameter is set. + * When using a `NDArrayMath` object in safe mode this must be used in a + * math.scope(). + * @param costTensor A tensor representing the cost to optimize. Should be a + * scalar. + * @param feedEntries Feed entries for this train run. Provides inputs. + * @param batchSize Batch size for this train loop. + * @param optimizer An optimizer to perform weight updates. + * @param costReduction An option to allow the user to get a summed, averaged, + * or no cost back. + * @return The reduced cost, if cost reduction is not NONE. The user is + * responsible for disposing the cost NDArray between train loops. + */ + train( + costTensor: Tensor, feedEntries: FeedEntry[], batchSize: number, + optimizer: Optimizer, costReduction = CostReduction.NONE): Scalar { + util.assert( + util.isScalarShape(costTensor.shape), + 'Cost tensor for training must be a scalar value.'); + + if (this.prevBatchSize !== batchSize) { + this.prevBatchSize = batchSize; + this.batchSizeScalar = Scalar.new(batchSize); + } + + const feed = new FeedDictionary(feedEntries); + session_util.throwIfFeedDictionaryContainsNDArrays(feed); + + const runtime = this.getOrCreateRuntime([costTensor], feed); + const inferenceOperations = runtime.operations; + const backPropOperations = runtime.operations.slice().reverse(); + const activations = this.activationArrayMap; + const gradients = this.gradientArrayMap; + gradients.set(costTensor, this.oneScalar); + + session_util.addPersistentArraysToTensorArrayMap( + runtime.nodes, activations); + + optimizer.beforeBatch( + this.math, batchSize, runtime, activations, gradients); + + return this.math.scope((keep, track) => { + let cost = track(Scalar.new(0)); + + for (let i = 0; i < batchSize; ++i) { + session_util.disposeAndInitializeOperationOutputs( + runtime.nodes, activations); + session_util.disposeAndInitializeOperationInputGradients( + runtime.nodes, gradients); + session_util.disposeTransientOperationArrays( + runtime.operations, activations, gradients); + + session_util.loadInputsFromFeedDictionaryToTensorArrayMap( + feed, activations, this.math); + + inferenceOperations.forEach( + op => op.feedForward(this.math, activations)); + backPropOperations.forEach( + op => op.backProp(this.math, activations, gradients)); + + optimizer.afterExample(this.math, runtime, activations, gradients); + + session_util.releaseFeedDictionaryInputsFromTensorArrayMap( + feed, activations, this.math); + + cost = this.updateCostForExample( + cost, activations.get(costTensor), costReduction); + } + + optimizer.afterBatch( + this.math, batchSize, runtime, activations, gradients); + + return this.updateCostForBatch(cost, costReduction); + }); + } + + private updateCostForExample( + totalCost: Scalar, currCost: Scalar, + costReduction: CostReduction): Scalar { + if (costReduction === CostReduction.MEAN || + costReduction === CostReduction.SUM) { + return this.math.add(totalCost, currCost); + } + return totalCost; + } + + private updateCostForBatch(totalCost: Scalar, costReduction: CostReduction): + Scalar { + if (costReduction === CostReduction.MEAN) { + return this.math.divide(totalCost, this.batchSizeScalar); + } + return totalCost; + } + + private getOrCreateRuntime(tensors: Tensor[], feed: FeedDictionary): + SessionRuntime { + const key = this.makeRuntimeCacheKey(tensors, feed); + let runtime = this.runtimeCache[key]; + if (runtime === undefined) { + let nodes = + session_util.getOrderedEvaluationSetFromEvalTensor(tensors, feed); + // In inference mode split nodes are not needed, but their cost is + // negligible, and always adding them in allows for caching of 1 runtime + // for both train/eval. + nodes = session_util.addSplitNodes(nodes); + session_util.removeFeedDictionaryNodesFromEvaluationSet(feed, nodes); + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes(nodes); + const operations = operation_emitter.emitFromGraphNodes(nodes); + runtime = {nodes, operations}; + this.runtimeCache[key] = runtime; + } + + return runtime; + } + + private makeRuntimeCacheKey(tensors: Tensor[], feed: FeedDictionary): string { + return tensors.map(x => x.id).sort().join('_') + '__' + + Object.keys(feed.dict).sort().join('_'); + } + + /** Maps each output tensor of the graph to its activation value. */ + activationArrayMap = new TensorArrayMap(); + /** Maps each tensor of the graph to its derivative wrt the cost function. */ + gradientArrayMap = new TensorArrayMap(); + private runtimeCache: {[key: string]: SessionRuntime} = {}; + /** Batch size of the previous train() call. */ + private prevBatchSize: number; + private batchSizeScalar: Scalar; + private oneScalar = Scalar.new(1); +} + +/** @hidden */ +export type SessionRuntime = { + nodes: Node[]; operations: Operation[]; +}; diff --git a/src/session_test.ts b/src/session_test.ts new file mode 100644 index 0000000000..1597478803 --- /dev/null +++ b/src/session_test.ts @@ -0,0 +1,314 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Graph, Tensor} from './graph'; +import {InputProvider} from './input_provider'; +import {NDArrayMathCPU} from './math/math_cpu'; +import {NDArrayMathGPU} from './math/math_gpu'; +import {Array1D, NDArray, Scalar} from './math/ndarray'; +import {MeanSquaredCost} from './ops/element_wise_cost'; +import {FeedDictionary, FeedEntry, Session} from './session'; +import {SGDOptimizer} from './sgd_optimizer'; +import * as test_util from './test_util'; + + +describe('FeedDictionary', () => { + it('ctor leaves dict empty if no args are passed', () => { + expect(Object.keys(new FeedDictionary().dict).length).toEqual(0); + }); + + it('ctor populates dict from only feed entry', () => { + const e: FeedEntry = {tensor: new Tensor([]), data: NDArray.zeros([1])}; + const d = new FeedDictionary([e]); + expect(Object.keys(d.dict).length).toEqual(1); + expect(d.dict[e.tensor.id]).toBe(e); + }); + + it('ctor populates dict from many entries', () => { + const entries: FeedEntry[] = [ + {tensor: new Tensor([]), data: NDArray.zeros([1])}, + {tensor: new Tensor([]), data: NDArray.zeros([1])}, + {tensor: new Tensor([]), data: NDArray.zeros([1])}, + {tensor: new Tensor([]), data: NDArray.zeros([1])} + ]; + const d = new FeedDictionary(entries); + expect(Object.keys(d.dict).length).toEqual(entries.length); + entries.forEach(entry => expect(d.dict[entry.tensor.id]).toBe(entry)); + }); + + it('add adds entry to map keyed on tensor id', () => { + const t = new Tensor([]); + const nda = NDArray.zeros([1]); + const fd = new FeedDictionary([{tensor: t, data: nda}]); + expect(fd.dict[t.id].tensor).toBe(t); + expect(fd.dict[t.id].data).toBe(nda); + }); +}); + +describe('Session', () => { + let g: Graph; + + beforeEach(() => g = new Graph()); + + it('mnist fc', () => { + const input = g.placeholder('input', [28 * 28]); + const fc0W = g.variable('fc0W', NDArray.zeros([32, 28 * 28])); + const fc0B = g.variable('fc0B', NDArray.zeros([32])); + const fc0 = g.add(g.matmul(fc0W, input), fc0B); + const relu0 = g.relu(fc0); + const fc1W = g.variable('fc1W', NDArray.zeros([32, 32])); + const fc1B = g.variable('fc1B', NDArray.zeros([32])); + const fc1 = g.add(g.matmul(fc1W, relu0), fc1B); + const relu1 = g.relu(fc1); + const fc2W = g.variable('fc2W', NDArray.zeros([32, 32])); + const fc2B = g.variable('fc2B', NDArray.zeros([32])); + const fc2 = g.add(g.matmul(fc2W, relu1), fc2B); + const relu2 = g.relu(fc2); + const fc3W = g.variable('fc3W', NDArray.zeros([10, 32])); + const fc3B = g.variable('fc3B', NDArray.zeros([10])); + const fc3 = g.add(g.matmul(fc3W, relu2), fc3B); + + const session = new Session(g, new NDArrayMathCPU()); + session.eval(fc3, [{tensor: input, data: NDArray.zeros([28 * 28])}]); + }); + + it('y=x^2 + 3: CPU', () => { + const x = g.placeholder('x', [2]); + const y = g.add(g.square(x), g.constant(3)); + const session = new Session(g, new NDArrayMathCPU()); + const yVal = session.eval(y, [{tensor: x, data: Array1D.new([5, 4])}]); + const expected = new Float32Array([28, 19]); + test_util.expectArraysClose(yVal.getValues(), expected, 1e-5); + }); + + it('y=x^2 + 3: GPU', () => { + const x = g.placeholder('x', [2]); + const y = g.add(g.square(x), g.constant(3)); + const math = new NDArrayMathGPU(); + const session = new Session(g, math); + + math.scope(() => { + const yVal = session.eval(y, [{tensor: x, data: Array1D.new([5, 4])}]); + const expected = new Float32Array([28, 19]); + test_util.expectArraysClose(yVal.getValues(), expected, 1e-5); + }); + }); + + it('Non-placeholder feed: y=x^2 + 3 (feed x^2)', () => { + const x = g.placeholder('x', [2]); + const xSquared = g.square(x); + const y = g.add(xSquared, g.constant(3)); + const math = new NDArrayMathGPU(); + const session = new Session(g, math); + + math.scope(() => { + const yVal = + session.eval(y, [{tensor: xSquared, data: Array1D.new([25, 16])}]); + const expected = new Float32Array([28, 19]); + test_util.expectArraysClose(yVal.getValues(), expected, 1e-5); + }); + }); + + it('Eval multiple tensors that share graph: y=x^2 + 3, z=x^2 + 2', () => { + const x = g.placeholder('x', [2]); + const xSquared = g.square(x); + const y = g.add(xSquared, g.constant(3)); + const z = g.add(xSquared, g.constant(2)); + const math = new NDArrayMathGPU(); + const session = new Session(g, math); + + math.scope(() => { + const result = + session.evalAll([y, z], [{tensor: x, data: Array1D.new([5, 4])}]); + const expectedY = new Float32Array([28, 19]); + const expectedZ = new Float32Array([27, 18]); + test_util.expectArraysClose(result[0].getValues(), expectedY, 1e-5); + test_util.expectArraysClose(result[1].getValues(), expectedZ, 1e-5); + }); + }); + + it('Backprop through a split node, input is scalar', () => { + const x = g.placeholder('x', []); + const y = g.square(x); + const z = g.add(x, g.constant(3)); + const w = g.add(y, z); + + const optimizer = new SGDOptimizer(0.1); + const session = new Session(g, new NDArrayMathCPU()); + let idx = 0; + const xs: Scalar[] = [Scalar.TWO, Scalar.ONE, Scalar.NEG_ONE]; + const inputProvider: InputProvider = { + getNextCopy() { + return xs[idx++]; + }, + disposeCopy(math, example) {} + }; + + // w = x^2 + x + 3 + // dw/dx = 2x + 1 + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer); + let dwdx = session.gradientArrayMap.get(x).get(); + expect(dwdx).toBe(5); + + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer); + dwdx = session.gradientArrayMap.get(x).get(); + expect(dwdx).toBe(3); + + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer); + dwdx = session.gradientArrayMap.get(x).get(); + expect(dwdx).toBe(-1); + }); + + it('Backprop through a split node, input is Array1D', () => { + const x = g.placeholder('x', [2]); + const y = g.square(x); + const z = g.add(x, g.constant(3)); + const w = g.reduceSum(g.add(y, z)); + + const optimizer = new SGDOptimizer(0.1); + const session = new Session(g, new NDArrayMathCPU()); + const inputProvider: InputProvider = { + getNextCopy() { + return Array1D.new([2, 4]); + }, + disposeCopy(math, example) {} + }; + + // w = reduce_sum(x^2 + x + 3) + // dw/dx = [2*x_1 + 1, 2*x_2 + 1] + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer); + const dwdx = session.gradientArrayMap.get(x).getValues(); + test_util.expectArraysClose(dwdx, new Float32Array([5, 9]), 1e-5); + }); + + it('Specify which variables to update (var_list)', () => { + const x = g.placeholder('x', [2]); + const b0 = g.variable('b0', NDArray.zeros([2])); + const p = g.add(x, b0); + const q = g.square(p); + const b1 = g.variable('b1', NDArray.zeros([2])); + const r = g.add(q, b1); + const yPrediction = g.reduceSum(r); + const yTrue = g.constant(1); + const cost = g.meanSquaredCost(yTrue, yPrediction); + + const session = new Session(g, new NDArrayMathCPU()); + const inputProvider: InputProvider = { + getNextCopy() { + return Array1D.new([1, 2]); + }, + disposeCopy(math, example) {} + }; + + // prediction = reduce_sum((x + b0)^2 + b1) + // dE/db0 = (1 - prediction) * [- 2*x_1 - 2*b0_1, - 2*x_2 - 2*b0_2] + // dE/db0_{x=[1,2], b0=[0,0]} = (8, 16) + + // Update only b0 + const optimizerOnlyB0 = new SGDOptimizer(0.1, [b0.node]); + session.train( + cost, [{tensor: x, data: inputProvider}], 2, optimizerOnlyB0, + undefined); + const b0After1 = session.activationArrayMap.get(b0).getValues(); + const b1After1 = session.activationArrayMap.get(b1).getValues(); + + test_util.expectArraysClose(b0After1, new Float32Array([-0.8, -1.6]), 1e-5); + test_util.expectArraysClose(b1After1, new Float32Array([0, 0]), 1e-5); + + // Update both b0 and b1 + const optimizerAll = new SGDOptimizer(0.1); + session.train( + cost, [{tensor: x, data: inputProvider}], 2, optimizerAll, undefined); + const b0After2 = session.activationArrayMap.get(b0).getValues(); + const b1After2 = session.activationArrayMap.get(b1).getValues(); + + expect(b0After2 === b0After1).toEqual(false); + expect(b1After2 === b1After1).toEqual(false); + }); + + it('Safe mode math, no math scope eval throws', () => { + const safeMode = true; + const x = g.placeholder('x', [2]); + const y = g.square(x); + const math = new NDArrayMathCPU(safeMode); + const session = new Session(g, math); + + expect(() => session.eval(y, [{tensor: x, data: Array1D.new([5, 4])}])) + .toThrowError(); + }); + + it('Safe mode math, math scope eval does not throw', () => { + const safeMode = true; + const x = g.placeholder('x', [2]); + const y = g.square(x); + const math = new NDArrayMathCPU(safeMode); + const session = new Session(g, math); + + math.scope(() => { + const yVal = session.eval(y, [{tensor: x, data: Array1D.new([5, 4])}]); + const expected = new Float32Array([25, 16]); + test_util.expectArraysClose(yVal.getValues(), expected, 1e-5); + }); + }); + + it('Safe mode math, math scope train does not throw', () => { + const x = g.placeholder('x', [2]); + const y = g.square(x); + const z = g.add(x, g.constant(3)); + const w = g.reduceSum(g.add(y, z)); + + const safeMode = true; + const optimizer = new SGDOptimizer(0.1); + const math = new NDArrayMathCPU(safeMode); + const session = new Session(g, math); + const inputProvider: InputProvider = { + getNextCopy() { + return Array1D.new([2, 4]); + }, + disposeCopy(math, example) {} + }; + + math.scope(() => { + // w = reduce_sum(x^2 + x + 3) + // dw/dx = [2*x_1 + 1, 2*x_2 + 1] + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer); + const dwdx = session.gradientArrayMap.get(x).getValues(); + test_util.expectArraysClose(dwdx, new Float32Array([5, 9]), 1e-5); + }); + }); + + it('Safe mode math, no math scope train throws', () => { + const x = g.placeholder('x', [2]); + const y = g.square(x); + const z = g.add(x, g.constant(3)); + const w = g.reduceSum(g.add(y, z)); + + const safeMode = true; + const optimizer = new SGDOptimizer(0.1); + const math = new NDArrayMathCPU(safeMode); + const session = new Session(g, math); + const inputProvider: InputProvider = { + getNextCopy() { + return Array1D.new([2, 4]); + }, + disposeCopy(math, example) {} + }; + + expect( + () => + session.train(w, [{tensor: x, data: inputProvider}], 1, optimizer)) + .toThrowError(); + }); +}); \ No newline at end of file diff --git a/src/session_util.ts b/src/session_util.ts new file mode 100644 index 0000000000..9ef12b3c53 --- /dev/null +++ b/src/session_util.ts @@ -0,0 +1,304 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {ConstantNode, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph'; +import * as graph_util from './graph_util'; +import {InputProvider} from './input_provider'; +import {NDArrayMath} from './math/math'; +import {NDArray} from './math/ndarray'; +import {Operation} from './ops/op'; +import {FeedDictionary} from './session'; +import {TensorArrayMap} from './tensor_array_map'; +import * as util from './util'; + +/** + * Creates an array of graph nodes that stop traversal, based on the contents + * of the provided FeedDictionary. This is a simple 1:1 extraction of nodes from + * the FeedDictionary. + * + * @hidden + * @param feedDictionary The FeedDictionary to scan for termination nodes. + * @return an array of Nodes which halt traversal when visited. + */ +export function getTerminatingNodesFromFeedDictionary( + feedDictionary: FeedDictionary): Node[] { + return Object.keys(feedDictionary.dict) + .map(tensorID => feedDictionary.dict[+tensorID].tensor.node); +} + +/** + * Given a tensor and a feed dictionary, computes the set of nodes that need to + * be evaluated to perform inference. + * + * @hidden + * @param evalTensors The list of tensors to eventually be evaluated. + * @param feedDictionary The populated feed dictionary. + * @return The set of nodes to evaluate, in evaluation order. + */ +export function getOrderedEvaluationSetFromEvalTensor( + evalTensors: Tensor[], feedDictionary: FeedDictionary): Node[] { + const terminatingNodes = + getTerminatingNodesFromFeedDictionary(feedDictionary); + const evalNodes = evalTensors.map(x => x.node); + const unorderedEvaluationSet = + graph_util.getUnorderedEvaluationSet(evalNodes, terminatingNodes); + const orderedEvaluationSet = + graph_util.getOrderedEvaluationSet(unorderedEvaluationSet); + return orderedEvaluationSet; +} + +/** + * Traverses the provided node array and adds all persistent node NDArrays to + * the provided TensorArrayMap. + * + * @hidden + * @param evaluationSet The array of nodes to scan. + * @param tensorArrayMap The map that receives the NDArrays from persistent + * nodes. + */ +export function addPersistentArraysToTensorArrayMap( + evaluationSet: Node[], tensorArrayMap: TensorArrayMap) { + evaluationSet.forEach(node => { + if (node instanceof VariableNode || node instanceof ConstantNode) { + tensorArrayMap.set(node.output, node.data); + } + }); +} + +/** + * @hidden + */ +export function getVariableNodesFromEvaluationSet(evaluationSet: Node[]): + VariableNode[] { + const nodes: VariableNode[] = []; + evaluationSet.forEach(node => { + if (node instanceof VariableNode) { + nodes.push(node); + } + }); + return nodes; +} + +/** + * @hidden + */ +export function throwIfFeedDictionaryContainsNDArrays( + feedDictionary: FeedDictionary) { + Object.keys(feedDictionary.dict).forEach(tensorID => { + if (feedDictionary.dict[+tensorID].data instanceof NDArray) { + throw new Error( + 'training requires FeedDictionary entries to be InputProviders' + + 'and not NDArrays.'); + } + }); +} + +/** + * @hidden + */ +export function loadInputsFromFeedDictionaryToTensorArrayMap( + batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) { + Object.keys(batchFeed.dict).forEach(tensorID => { + const feedEntry = batchFeed.dict[+tensorID]; + + let data: NDArray; + if (feedEntry.data instanceof NDArray) { + data = feedEntry.data as NDArray; + } else { + const provider = feedEntry.data as InputProvider; + data = provider.getNextCopy(math); + } + + util.assert( + util.arraysEqual(feedEntry.tensor.shape, data.shape), + `Error loading FeedEntry: feeding NDArray of shape ${data.shape} ` + + `does not match Tensor (id: ${feedEntry.tensor.id}) shape: ` + + `${feedEntry.tensor.shape}.`); + activations.set(feedEntry.tensor, data); + }); +} + + +/** + * @hidden + */ +export function releaseFeedDictionaryInputsFromTensorArrayMap( + batchFeed: FeedDictionary, activations: TensorArrayMap, math: NDArrayMath) { + Object.keys(batchFeed.dict).forEach(tensorID => { + const feedEntry = batchFeed.dict[+tensorID]; + + if (!(feedEntry.data instanceof NDArray)) { + const provider = feedEntry.data as InputProvider; + + const feedEntryArray = activations.get(feedEntry.tensor); + provider.disposeCopy(math, feedEntryArray); + } + + activations.delete(feedEntry.tensor); + }); +} + +/** + * Removes all nodes from the provided Node array whose output tensors exist in + * the provided feed dictionary. After calling this, the Node array should + * contain zero Placeholder nodes, or the user has failed to provide a feed for + * a Placeholder node. + * + * @hidden + * @param feedDictionary The FeedDictionary to process. + * @param evaluationSet The array of nodes to remove input nodes from. + */ +export function removeFeedDictionaryNodesFromEvaluationSet( + feedDictionary: FeedDictionary, evaluationSet: Node[]) { + let i = 0; + while (i < evaluationSet.length) { + const node = evaluationSet[i]; + if (feedDictionary.dict[node.output.id] != null) { + evaluationSet.splice(i, 1); + } else { + ++i; + } + } +} + +/** + * Disposes any NDArrays on the tensorArrayMap from operation outputs and sets + * the value to null. + * + * @hidden + * @param evaluationSet The set of nodes to be evaluated. + * @param tensorArrayMap The map to dispose and initialize. + */ +export function disposeAndInitializeOperationOutputs( + evaluationSet: Node[], tensorArrayMap: TensorArrayMap) { + evaluationSet.forEach(node => { + if (!graph_util.isInputNode(node)) { + if (!graph_util.isPassthroughNode(node, tensorArrayMap)) { + tensorArrayMap.disposeArray(node.output); + } + tensorArrayMap.set(node.output, null); + } + }); +} + +/** + * Disposes any NDArrays on the tensorArrayMap from derivatives of operation + * inputs and sets the value to null. + * + * @hidden + * @param evaluationSet The set of nodes to be evaluated. + * @param gradients The gradient map to dispose and initialize. + */ +export function disposeAndInitializeOperationInputGradients( + evaluationSet: Node[], gradients: TensorArrayMap) { + evaluationSet.forEach(node => { + Object.keys(node.inputs).forEach(inputName => { + const input = node.inputs[inputName]; + if (gradients.get(input, true) !== gradients.get(node.output, true)) { + gradients.disposeArray(input); + } + gradients.set(input, null); + }); + }); +} + + +/** + * Calls underlying operation disposeTransientArrays methods which clean up any + * NDArrays which operations may have created during a run. + * + * @hidden + * @param operationNodes The array of Nodes to traverse. + * @param outputTensor The tensor being evaluated. + * @param map The TensorArrayMap to operate on. + */ +export function disposeTransientOperationArrays( + operations: Operation[], activations: TensorArrayMap, + gradients: TensorArrayMap) { + operations.forEach(op => op.disposeTransientArrays(activations, gradients)); +} + +/** + * Iterates the provided Node array and throws an exception if there are any + * Placeholder nodes present. Call after the evaluation set has been pruned with + * the accompanying FeedDictionary to ensure that all inputs have been resolved. + * + * @hidden + * @param evaluationSet The array of nodes to scan. + */ +export function throwErrorIfEvaluationSetContainsPlaceholderNodes( + evaluationSet: Node[]) { + evaluationSet.forEach(node => { + if (node instanceof PlaceholderNode) { + const shape = '[' + node.output.shape.join(', ') + ']'; + throw new Error( + 'Placeholder node "' + node.name + '" ' + shape + + ' not present in feed dictionary.'); + } + }); +} + +/** + * Injects splits nodes after every node that has multiple consumers. + * + * @hidden + * @param nodes The node list in evaluation order. + * @return The node list with split nodes injected. + */ +export function addSplitNodes(nodes: Node[]): Node[] { + const nodeIdToNumConsumers: number[] = []; + const nodeIdToSplitNode: {[nodeId: number]: SplitNode} = {}; + + // Find nodes that have multiple consumers. + nodes.forEach(node => { + const keys = Object.keys(node.inputs); + keys.forEach(key => { + const inputTensor = node.inputs[key]; + const input = inputTensor.node; + if (nodeIdToNumConsumers[input.id] == null) { + nodeIdToNumConsumers[input.id] = 0; + } + nodeIdToNumConsumers[input.id]++; + if (nodeIdToNumConsumers[input.id] > 1 && + nodeIdToSplitNode[input.id] == null) { + nodeIdToSplitNode[input.id] = new SplitNode(input.graph, inputTensor); + } + }); + }); + + // Inject a split node after each node that has multiple consumers and + // rewire the inputs of the consumers to consume the output tensors of the + // split node instead of the original node. Each consumer consumes a + // different output tensor so that derivatives are not overwritten. + // x-->y becomes x-->s-->y where y consumes the 1st output tensor of s + // |-->z |-->z and z consumes the 2nd output tensor of s + const newNodes: Node[] = []; + nodes.forEach(node => { + newNodes.push(node); + if (node.id in nodeIdToSplitNode) { + const splitNode = nodeIdToSplitNode[node.id]; + newNodes.push(splitNode); + } + const keys = Object.keys(node.inputs); + keys.forEach(key => { + const inputTensor = node.inputs[key]; + const inputId = inputTensor.node.id; + if (inputId in nodeIdToSplitNode) { + node.inputs[key] = nodeIdToSplitNode[inputId].getNewOutputTensor(); + } + }); + }); + return newNodes; +} diff --git a/src/session_util_test.ts b/src/session_util_test.ts new file mode 100644 index 0000000000..1c36f9b80f --- /dev/null +++ b/src/session_util_test.ts @@ -0,0 +1,464 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {ConstantNode, Graph, Node, PlaceholderNode, SplitNode, Tensor, VariableNode} from './graph'; +import {InputProvider} from './input_provider'; +import {NDArrayMathCPU} from './math/math_cpu'; +import {NDArray} from './math/ndarray'; +import {FeedDictionary, FeedEntry} from './session'; +import * as session_util from './session_util'; +import {TensorArrayMap} from './tensor_array_map'; + +class TestNode extends Node { + validate() {} +} + +describe('getTerminatingNodesFromFeedDictionary', () => { + + it('returns an empty node array from an empty FeedDictionary', () => { + expect(session_util.getTerminatingNodesFromFeedDictionary( + new FeedDictionary())) + .toEqual([]); + }); + + it('returns the only node in the feed dictionary', () => { + const node = new TestNode(new Graph(), '', {}, new Tensor([])); + const fd = + new FeedDictionary([{tensor: node.output, data: NDArray.zeros([1])}]); + expect(session_util.getTerminatingNodesFromFeedDictionary(fd)).toEqual([ + node + ]); + }); + + it('returns every node from the feed dictionary', () => { + const n0 = new TestNode(new Graph(), '', {}, new Tensor([])); + const n1 = new TestNode(new Graph(), '', {}, new Tensor([])); + const n2 = new TestNode(new Graph(), '', {}, new Tensor([])); + const n3 = new TestNode(new Graph(), '', {}, new Tensor([])); + const n4 = new TestNode(new Graph(), '', {}, new Tensor([])); + const feeds: FeedEntry[] = [ + {tensor: n0.output, data: NDArray.zeros([1])}, + {tensor: n1.output, data: NDArray.zeros([1])}, + {tensor: n2.output, data: NDArray.zeros([1])}, + {tensor: n3.output, data: NDArray.zeros([1])}, + {tensor: n4.output, data: NDArray.zeros([1])} + ]; + const fd = new FeedDictionary(feeds); + const nodes = session_util.getTerminatingNodesFromFeedDictionary(fd); + expect(nodes).toContain(n0); + expect(nodes).toContain(n1); + expect(nodes).toContain(n2); + expect(nodes).toContain(n3); + expect(nodes).toContain(n4); + }); +}); + +describe('addPersistentArraysToTensorArrayMap', () => { + let map: TensorArrayMap; + let g: Graph; + beforeEach(() => { + map = new TensorArrayMap(); + g = new Graph(); + }); + + it('does nothing with empty evaluationSet', () => { + session_util.addPersistentArraysToTensorArrayMap([], map); + expect(map.size()).toEqual(0); + }); + + it('adds the only VariableNode to the map', () => { + const v = new VariableNode(g, '', NDArray.zeros([1])); + session_util.addPersistentArraysToTensorArrayMap([v], map); + expect(map.get(v.output)).toBe(v.data); + }); + + it('adds the only ConstantNode to the map', () => { + const c = new ConstantNode(g, NDArray.zeros([1])); + session_util.addPersistentArraysToTensorArrayMap([c], map); + expect(map.get(c.output)).toBe(c.data); + }); + + it('does nothing with nodes that aren\'t VariableNodes or ConstantNodes', + () => { + const nodes = [new TestNode(g, '', {}, new Tensor([]))]; + session_util.addPersistentArraysToTensorArrayMap(nodes, map); + expect(map.size()).toEqual(0); + }); + + it('adds multiple VariableNodes to the map', () => { + const nodes = [ + new VariableNode(g, '', NDArray.zeros([1])), + new VariableNode(g, '', NDArray.zeros([1])), + new VariableNode(g, '', NDArray.zeros([1])) + ]; + session_util.addPersistentArraysToTensorArrayMap(nodes, map); + expect(map.get(nodes[0].output)).toBe(nodes[0].data); + expect(map.get(nodes[1].output)).toBe(nodes[1].data); + expect(map.get(nodes[2].output)).toBe(nodes[2].data); + }); + + it('adds multiple ConstantNodes to the map', () => { + const nodes = [ + new ConstantNode(g, NDArray.zeros([1])), + new ConstantNode(g, NDArray.zeros([1])), + new ConstantNode(g, NDArray.zeros([1])) + ]; + session_util.addPersistentArraysToTensorArrayMap(nodes, map); + expect(map.get(nodes[0].output)).toBe(nodes[0].data); + expect(map.get(nodes[1].output)).toBe(nodes[1].data); + expect(map.get(nodes[2].output)).toBe(nodes[2].data); + }); + + it('skips non-VariableNode or ConstantNode entries in the set', () => { + const nodes: Node[] = [ + new TestNode(g, '', {}, new Tensor([])), + new VariableNode(g, '', NDArray.zeros([1])), + new TestNode(g, '', {}, new Tensor([])), + new ConstantNode(g, NDArray.zeros([1])), + new TestNode(g, '', {}, new Tensor([])), + new VariableNode(g, '', NDArray.zeros([1])) + ]; + session_util.addPersistentArraysToTensorArrayMap(nodes, map); + expect(map.size()).toEqual(3); + expect(map.get(nodes[1].output)).toBe((nodes[1] as VariableNode).data); + expect(map.get(nodes[3].output)).toBe((nodes[3] as ConstantNode).data); + expect(map.get(nodes[5].output)).toBe((nodes[5] as VariableNode).data); + }); +}); + +describe('loadInputsFromFeedDictionaryToTensorArrayMap', () => { + let map: TensorArrayMap; + let math: NDArrayMathCPU; + + beforeEach(() => { + math = new NDArrayMathCPU(); + map = new TensorArrayMap(); + }); + + it('does nothing with empty feed dictionary', () => { + const fd = new FeedDictionary(); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(0); + }); + + it('adds the only NDArray feed dict entry to the map', () => { + const tensor = new Tensor([1]); + const fd = new FeedDictionary([{tensor, data: NDArray.zeros([1])}]); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(1); + expect(map.get(tensor)).toBe(fd.dict[tensor.id].data as NDArray); + }); + + it('adds the only provider feed dict entry to the map', () => { + const tensor = new Tensor([2]); + const ndarray = NDArray.zeros([2]); + const provider: InputProvider = { + getNextCopy(): NDArray { + // Don't return a copy in this case so we can test that we returned the + // right value. + return ndarray; + }, + // No need to dispose when not using NDArrayMathGPU. + disposeCopy() {} + }; + const fd = new FeedDictionary([{tensor, data: provider}]); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(1); + expect(map.get(tensor)).toBe(ndarray); + }); + + it('adds every NDArray feed dict entry to the map', () => { + const tensors = [ + new Tensor([1]), new Tensor([1]), new Tensor([1]), new Tensor([1]), + new Tensor([1]) + ]; + const feeds = tensors.map(tensor => { + return {tensor, data: NDArray.zeros([1])}; + }); + const fd = new FeedDictionary(feeds); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(tensors.length); + tensors.forEach( + tensor => + expect(map.get(tensor)).toBe(fd.dict[tensor.id].data as NDArray)); + }); + + it('adds every provider feed dict entry to the map', () => { + const tensors = [ + new Tensor([1]), new Tensor([1]), new Tensor([1]), new Tensor([1]), + new Tensor([1]) + ]; + const ndarrays: NDArray[] = []; + for (let i = 0; i < tensors.length; i++) { + ndarrays.push(NDArray.zeros([1])); + } + let idx = 0; + const provider: InputProvider = { + getNextCopy(): NDArray { + const ndarray = ndarrays[idx]; + idx++; + return ndarray; + }, + disposeCopy() {} + }; + + const feeds: FeedEntry[] = []; + for (let i = 0; i < tensors.length; i++) { + feeds.push({tensor: tensors[i], data: provider}); + } + + const fd = new FeedDictionary(feeds); + session_util.loadInputsFromFeedDictionaryToTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(tensors.length); + for (let i = 0; i < tensors.length; i++) { + expect(map.get(tensors[i])).toBe(ndarrays[i]); + } + }); + + it('throws when provides data that does not match tensor shape', () => { + const tensor = new Tensor([4, 5]); + const fd = new FeedDictionary([{tensor, data: NDArray.zeros([2, 3])}]); + expect( + () => session_util.loadInputsFromFeedDictionaryToTensorArrayMap( + fd, map, math)) + .toThrowError(); + }); +}); + +describe('releaseFeedDictionaryInputsFromTensorArrayMap', () => { + let map: TensorArrayMap; + let math: NDArrayMathCPU; + + beforeEach(() => { + map = new TensorArrayMap(); + math = new NDArrayMathCPU(); + }); + + it('doesn\'t remove anything when feed dictionary is empty', () => { + map.set(new Tensor([]), null); + const fd = new FeedDictionary(); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(1); + }); + + it('doesn\'t remove tensors from map that don\'t exist in feed', () => { + const fdTensor = new Tensor([]); + const nda = NDArray.zeros([1]); + const fd = + new FeedDictionary([{tensor: fdTensor, data: NDArray.zeros([1])}]); + const nonFDTensor = new Tensor([]); + map.set(nonFDTensor, nda); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(1); + expect(map.get(nonFDTensor)).toBe(nda); + }); + + it('removes only tensor in map and feed dict', () => { + const tensor = new Tensor([]); + const ndarray = NDArray.zeros([1]); + const fd = new FeedDictionary([{tensor, data: ndarray}]); + map.set(tensor, ndarray); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(0); + }); + + it('removes from map all tensors in feed dict', () => { + const tensors = [new Tensor([]), new Tensor([]), new Tensor([])]; + + const feeds = tensors.map(tensor => { + return {tensor, data: NDArray.zeros([1])}; + }); + const fd = new FeedDictionary(feeds); + tensors.forEach( + tensor => map.set(tensor, fd.dict[tensor.id].data as NDArray)); + session_util.releaseFeedDictionaryInputsFromTensorArrayMap(fd, map, math); + expect(map.size()).toEqual(0); + }); +}); + +describe('disposeAndInitializeOperationOutputs', () => { + let map: TensorArrayMap; + let g: Graph; + beforeEach(() => { + map = new TensorArrayMap(); + g = new Graph(); + }); + + it('does nothing to map if set is empty', () => { + session_util.disposeAndInitializeOperationOutputs([], map); + expect(map.size()).toEqual(0); + }); + + it('does nothing to map if set has no input nodes', () => { + const nodes = [ + new VariableNode(g, '', NDArray.zeros([1])), + new PlaceholderNode(g, '', [1]) + ]; + session_util.disposeAndInitializeOperationOutputs(nodes, map); + expect(map.size()).toEqual(0); + }); + + it('adds output tensor from only operation node', () => { + const input = new Tensor([]); + const t = new Tensor([]); + session_util.disposeAndInitializeOperationOutputs( + [new TestNode(g, '', {'in': input}, t)], map); + expect(map.size()).toEqual(1); + expect(map.hasNullArray(t)).toEqual(true); + }); + + it('adds output tensors from all operation nodes', () => { + const input = new Tensor([]); + const tensors = [new Tensor([]), new Tensor([]), new Tensor([])]; + const nodes: Node[] = []; + tensors.forEach( + tensor => nodes.push(new TestNode(g, '', {'in': input}, tensor))); + session_util.disposeAndInitializeOperationOutputs(nodes, map); + expect(map.size()).toEqual(nodes.length); + tensors.forEach(tensor => expect(map.hasNullArray(tensor)).toEqual(true)); + }); +}); + +describe('removeFeedDictionaryNodesFromEvaluationSet', () => { + let set: Node[]; + + beforeEach(() => { + set = []; + }); + + it('does nothing when feed dictionary is empty', () => { + const node = new TestNode(new Graph(), '', {}, new Tensor([])); + set.push(node); + const fd = new FeedDictionary(); + session_util.removeFeedDictionaryNodesFromEvaluationSet(fd, set); + expect(set.length).toEqual(1); + expect(set[0]).toBe(node); + }); + + it('removes only feed dict node from set', () => { + set.push(new TestNode(new Graph(), '', {}, new Tensor([]))); + const fd = + new FeedDictionary([{tensor: set[0].output, data: NDArray.zeros([1])}]); + session_util.removeFeedDictionaryNodesFromEvaluationSet(fd, set); + expect(set.length).toEqual(0); + }); + + it('removes only feed dict nodes from set', () => { + const g = new Graph(); + const remainingNodes = [ + new TestNode(g, '', {}, new Tensor([])), + new TestNode(g, '', {}, new Tensor([])), + new TestNode(g, '', {}, new Tensor([])) + ]; + + set.push(remainingNodes[0]); + set.push(new TestNode(g, '', {}, new Tensor([]))); + const feeds: FeedEntry[] = []; + feeds.push({tensor: set[set.length - 1].output, data: NDArray.zeros([1])}); + set.push(remainingNodes[1]); + set.push(new TestNode(g, '', {}, new Tensor([]))); + feeds.push({tensor: set[set.length - 1].output, data: NDArray.zeros([1])}); + set.push(remainingNodes[2]); + + const fd = new FeedDictionary(feeds); + session_util.removeFeedDictionaryNodesFromEvaluationSet(fd, set); + expect(set).toEqual(remainingNodes); + }); +}); + +describe('throwErrorIfEvaluationSetContainsPlaceholderNodes', () => { + let g: Graph; + beforeEach(() => g = new Graph()); + + it('doesn\'t throw on an empty node array', () => { + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes([]); + }); + + it('doesn\'t throw if array contains non-placeholder nodes', () => { + session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes( + [new TestNode(g, '', {}, new Tensor([]))]); + }); + + it('throws if the array only contains a placeholder node', () => { + expect( + () => session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes( + [new PlaceholderNode(g, '', [])])) + .toThrowError(/Placeholder node/); + }); + + it('thrown error contains the tensor shape', () => { + expect( + () => session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes( + [new PlaceholderNode(g, '', [1, 2, 3, 4, 5])])) + .toThrowError(/[1, 2, 3, 4, 5]/); + }); + + it('throws if the non-first element in the array is a placeholder', () => { + expect( + () => session_util.throwErrorIfEvaluationSetContainsPlaceholderNodes([ + new TestNode(g, '', {}, new Tensor([])), + new PlaceholderNode(g, '', []) + ])) + .toThrowError(/Placeholder node/); + }); +}); + +describe('Add split nodes', () => { + let g: Graph; + let nodes: Node[]; + + beforeEach(() => { + g = new Graph(); + nodes = []; + }); + + it('does not add split nodes', () => { + const a = new TestNode(g, 'A', {}, new Tensor([])); + const b = new TestNode(g, 'B', {'a': a.output}, new Tensor([])); + nodes.push(a); + nodes.push(b); + const newNodes = session_util.addSplitNodes(nodes); + expect(newNodes.length).toBe(2); + }); + + it('does add split a node before A', () => { + const a = new TestNode(g, 'A', {}, new Tensor([])); + const b = new TestNode(g, 'B', {'a': a.output}, new Tensor([])); + const c = new TestNode(g, 'C', {'a': a.output}, new Tensor([])); + nodes.push(a); + nodes.push(b); + nodes.push(c); + const newNodes = session_util.addSplitNodes(nodes); + expect(newNodes.length).toBe(4); + }); + + it('adds a split node in the right location with correct input/output', + () => { + const a = new TestNode(g, 'A', {}, new Tensor([])); + const b = new TestNode(g, 'B', {'a': a.output}, new Tensor([])); + const c = new TestNode(g, 'C', {'a': a.output}, new Tensor([])); + nodes.push(a); + nodes.push(b); + nodes.push(c); + const newNodes = session_util.addSplitNodes(nodes); + expect(newNodes.length).toBe(4); + const splitNode = newNodes[1] as SplitNode; + expect(splitNode instanceof SplitNode); + expect(splitNode.inputs[SplitNode.X] === a.output); + expect(splitNode.outputs.length).toBe(2); + expect(b.inputs['a'].id in splitNode.outputs.map(o => o.id)); + expect(c.inputs['a'].id in splitNode.outputs.map(o => o.id)); + }); +}); diff --git a/src/sgd_optimizer.ts b/src/sgd_optimizer.ts new file mode 100644 index 0000000000..a98e42b7b1 --- /dev/null +++ b/src/sgd_optimizer.ts @@ -0,0 +1,93 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Node, Tensor, VariableNode} from './graph'; +import {NDArrayMath} from './math/math'; +import {NDArray, Scalar} from './math/ndarray'; +import {Optimizer} from './optimizer'; +import {SessionRuntime} from './session'; +import * as session_util from './session_util'; +import {TensorArrayMap} from './tensor_array_map'; + +export class SGDOptimizer extends Optimizer { + constructor(private learningRate: number, specifiedVariableList?: Node[]) { + super(specifiedVariableList); + } + + beforeBatch( + math: NDArrayMath, batchSize: number, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) { + this.variableNodes = this.specifiedVariableNodes == null ? + session_util.getVariableNodesFromEvaluationSet(runtime.nodes) : + this.specifiedVariableNodes; + if (batchSize !== this.prevBatchSize) { + this.prevBatchSize = batchSize; + this.c = Scalar.new(-this.learningRate / batchSize); + } + this.variableNodes.forEach( + node => this.variableGradients.set( + node.output, NDArray.zeros(node.output.shape))); + } + + afterExample( + math: NDArrayMath, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) { + math.scope((keep) => { + this.variableNodes!.forEach(node => { + const gradient = gradientArrayMap.get(node.output); + const accumulatedGradient = this.variableGradients.get(node.output); + this.variableGradients.set( + node.output, keep(math.add(gradient, accumulatedGradient))); + accumulatedGradient.dispose(); + }); + }); + } + + afterBatch( + math: NDArrayMath, batchSize: number, runtime: SessionRuntime, + activationArrayMap: TensorArrayMap, gradientArrayMap: TensorArrayMap) { + math.scope((keep) => { + this.variableNodes!.forEach(node => { + const oldVariable = activationArrayMap.get(node.output); + const gradient = this.variableGradients.get(node.output); + const variable = + math.scaledArrayAdd(this.c!, gradient, this.one!, oldVariable); + activationArrayMap.set(node.output, keep(variable)); + node.data = variable; + + oldVariable.dispose(); + }); + }); + + this.variableGradients.dispose(); + this.variableGradients = new TensorArrayMap(); + } + + dispose() { + if (this.c != null) { + this.c.dispose(); + } + this.one.dispose(); + } + + setLearningRate(learningRate: number) { + this.learningRate = learningRate; + } + + private variableGradients = new TensorArrayMap(); + private prevBatchSize: number; + private one = Scalar.new(1); + private c: Scalar; +} diff --git a/src/tensor_array_map.ts b/src/tensor_array_map.ts new file mode 100644 index 0000000000..057506f804 --- /dev/null +++ b/src/tensor_array_map.ts @@ -0,0 +1,107 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from './graph'; +import {NDArray} from './math/ndarray'; + +/** + * TensorArrayMap is an internal map from Tensor IDs to NDArrays. Since NDArrays + * can be backed by WebGL textures, the TensorArrayMap is only used inside of a + * Session. + */ +export class TensorArrayMap { + /** + * Add or replace an entry in the map. + * @param tensor The tensor key. + * @param array The NDArray value, can be null. + */ + set(tensor: Tensor, array: NDArray|null) { + this.dict[tensor.id] = array; + } + + /** + * Returns the NDArray associated with the provided tensor. Will throw an + * exception if the tensor is not a key in the map, or if the associated + * NDArray is null. + * @param tensor The tensor key. + * @param skipChecks False by default. If true will skip all checks. + * @return The NDArray associated with the tensor. + */ + get(tensor: Tensor, skipChecks = false): NDArray { + if (!skipChecks && this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + const nda = this.dict[tensor.id]; + if (!skipChecks && nda === null) { + throw new Error('tensor ' + tensor.id + ' has null array.'); + } + return nda!; + } + + /** + * Removes a tensor/NDArray pair from the map. + * @param tensor The tensor key. + */ + delete(tensor: Tensor) { + delete this.dict[tensor.id]; + } + + disposeArray(tensor: Tensor) { + if (this.dict[tensor.id] === undefined) { + return; + } + const nda = this.dict[tensor.id]; + if (nda === null) { + return; + } + nda.dispose(); + this.dict[tensor.id] = null; + } + + /** + * @return The number of tensor/NDArray pairs in the map. + */ + size(): number { + return Object.keys(this.dict).length; + } + + /** + * Iterate over all contained NDArray values and dispose them. + */ + dispose() { + Object.keys(this.dict).forEach(tensorID => { + const nda = this.dict[+tensorID]; + if (nda) { + nda.dispose(); + } + }); + this.dict = {}; + } + + /** + * Tests to see if a tensor has a null associated with it. Throws + * if the tensor is not a key in the map. + * @param tensor The tensor key. + * @return True if the associated NDArray is null, else False. + */ + hasNullArray(tensor: Tensor): boolean { + if (this.dict[tensor.id] === undefined) { + throw new Error('tensor ' + tensor.id + ' not in array map.'); + } + return this.dict[tensor.id] === null; + } + + private dict: {[tensorID: number]: NDArray | null} = {}; +} diff --git a/src/tensor_array_map_test.ts b/src/tensor_array_map_test.ts new file mode 100644 index 0000000000..b58d0cfdc4 --- /dev/null +++ b/src/tensor_array_map_test.ts @@ -0,0 +1,108 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import {Tensor} from './graph'; +import {NDArray} from './math/ndarray'; +import {TensorArrayMap} from './tensor_array_map'; + +describe('TensorArrayMap.size', () => { + it('is 0 at construction', () => { + expect((new TensorArrayMap()).size()).toEqual(0); + }); + + it('is 1 after add', () => { + const map = new TensorArrayMap(); + map.set(new Tensor([]), NDArray.zeros([1])); + expect(map.size()).toEqual(1); + }); + + it('increments for every add', () => { + const map = new TensorArrayMap(); + for (let i = 0; i < 9; ++i) { + map.set(new Tensor([]), NDArray.zeros([1])); + } + expect(map.size()).toEqual(9); + }); +}); + +describe('TensorArrayMap.hasNullArray', () => { + let map: TensorArrayMap; + let t: Tensor; + beforeEach(() => { + map = new TensorArrayMap(); + t = new Tensor([]); + }); + + it('returns true for null NDArray entries', () => { + map.set(t, null); + expect(map.hasNullArray(t)).toBe(true); + }); + + it('returns false for non-null NDArray entries', () => { + map.set(t, NDArray.zeros([1])); + expect(map.hasNullArray(t)).toBe(false); + }); + + it('throws for missing keys', () => { + expect(() => map.hasNullArray(t)).toThrowError(/not in array map/); + }); +}); + +describe('TensorArrayMap.get', () => { + let map: TensorArrayMap; + let t: Tensor; + beforeEach(() => { + map = new TensorArrayMap(); + t = new Tensor([]); + }); + + it('returns the associated NDArray', () => { + const nda = NDArray.zeros([1]); + map.set(t, nda); + expect(map.get(t)).toBe(nda); + }); + + it('throws if associated NDArray is null', () => { + map.set(t, null); + expect(() => map.get(t)).toThrowError(/has null array/); + }); + + it('throws for missing key', () => { + expect(() => map.get(t)).toThrowError(/not in array map/); + }); +}); + +describe('TensorArrayMap.delete', () => { + let map: TensorArrayMap; + let t: Tensor; + beforeEach(() => { + map = new TensorArrayMap(); + t = new Tensor([]); + }); + + it('deletes the key from the map', () => { + map.set(t, null); + map.delete(t); + expect(() => map.get(t)).toThrow(); + }); + + it('is tolerant of deleting nonexistent keys', () => { + map.set(t, null); + map.delete(t); + map.delete(t); + map.delete(t); + map.delete(t); + }); +}); diff --git a/src/test_util.ts b/src/test_util.ts new file mode 100644 index 0000000000..d7682df6e8 --- /dev/null +++ b/src/test_util.ts @@ -0,0 +1,92 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export function expectArraysClose( + actual: Float32Array, expected: Float32Array, epsilon: number) { + if (actual.length !== expected.length) { + throw new Error( + 'Matrices have different lengths (' + actual.length + ' vs ' + + expected.length + ').'); + } + for (let i = 0; i < expected.length; ++i) { + const a = actual[i]; + const e = expected[i]; + if (isNaN(a) && isNaN(e)) { + continue; + } + if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon) { + const actualStr = 'actual[' + i + '] === ' + a; + const expectedStr = 'expected[' + i + '] === ' + e; + throw new Error('Arrays differ: ' + actualStr + ', ' + expectedStr); + } + } +} + +export function randomArrayInRange( + n: number, minValue: number, maxValue: number): Float32Array { + const v = new Float32Array(n); + const range = maxValue - minValue; + for (let i = 0; i < n; ++i) { + v[i] = (Math.random() * range) + minValue; + } + return v; +} + +export function makeIdentity(n: number): Float32Array { + const i = new Float32Array(n * n); + for (let j = 0; j < n; ++j) { + i[(j * n) + j] = 1; + } + return i; +} + +export function setValue( + m: Float32Array, mNumRows: number, mNumCols: number, v: number, row: number, + column: number) { + if (row >= mNumRows) { + throw new Error('row (' + row + ') must be in [0 ' + mNumRows + '].'); + } + if (column >= mNumCols) { + throw new Error('column (' + column + ') must be in [0 ' + mNumCols + '].'); + } + m[(row * mNumCols) + column] = v; +} + +export function cpuMultiplyMatrix( + a: Float32Array, aRow: number, aCol: number, b: Float32Array, bRow: number, + bCol: number) { + const result = new Float32Array(aRow * bCol); + for (let r = 0; r < aRow; ++r) { + for (let c = 0; c < bCol; ++c) { + let d = 0; + for (let k = 0; k < aCol; ++k) { + d += a[(r * aCol) + k] * b[(k * bCol) + c]; + } + result[(r * bCol) + c] = d; + } + } + return result; +} + +export function cpuDotProduct(a: Float32Array, b: Float32Array): number { + if (a.length !== b.length) { + throw new Error('cpuDotProduct: incompatible vectors.'); + } + let d = 0; + for (let i = 0; i < a.length; ++i) { + d += a[i] * b[i]; + } + return d; +} diff --git a/src/util.ts b/src/util.ts new file mode 100644 index 0000000000..a130c1524c --- /dev/null +++ b/src/util.ts @@ -0,0 +1,182 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +export type Vector = number[] | Float64Array | Float32Array | Int32Array | + Int8Array | Int16Array; + +/** Shuffles the array using Fisher-Yates algorithm. */ +// tslint:disable-next-line:no-any +export function shuffle(array: any[]|Uint32Array|Int32Array| + Float32Array): void { + let counter = array.length; + let temp = 0; + let index = 0; + // While there are elements in the array + while (counter > 0) { + // Pick a random index + index = (Math.random() * counter) | 0; + // Decrease counter by 1 + counter--; + // And swap the last element with it + temp = array[counter]; + array[counter] = array[index]; + array[index] = temp; + } +} + +/** Clamps a value to a specified range. */ +export function clamp(min: number, x: number, max: number): number { + return Math.max(min, Math.min(x, max)); +} + +/** Returns a sample from a uniform [a, b] distribution. */ +export function randUniform(a: number, b: number) { + return Math.random() * (b - a) + a; +} + +/** + * Samples from a gaussian distribution. + * + * @param mean The mean. Default is 0. + * @param stdDev The standard deviation. Default is 1. + */ +export function randGauss(mean = 0, stdDev = 1, truncated = false): number { + let v1: number, v2: number, s: number; + do { + v1 = 2 * Math.random() - 1; + v2 = 2 * Math.random() - 1; + s = v1 * v1 + v2 * v2; + } while (s > 1); + + const result = Math.sqrt(-2 * Math.log(s) / s) * v1; + if (truncated && result > 2) { + return randGauss(mean, stdDev, true); + } + return mean + stdDev * result; +} + +/** Returns squared eucledian distance between two vectors. */ +export function distSquared(a: Vector, b: Vector): number { + let result = 0; + for (let i = 0; i < a.length; i++) { + const diff = a[i] - b[i]; + result += diff * diff; + } + return result; +} + +export function assert(expr: boolean, msg: string) { + if (!expr) { + throw new Error(msg); + } +} + +export function assertShapesMatch( + shapeA: number[], shapeB: number[], errorMessagePrefix = ''): void { + assert( + arraysEqual(shapeA, shapeB), + errorMessagePrefix + `Shapes ${shapeA} and ${shapeB} must match`); +} + +// tslint:disable-next-line:no-any +export function flatten(arr: any[], ret?: number[]): number[] { + ret = (ret === undefined ? [] : ret); + for (let i = 0; i < arr.length; ++i) { + if (Array.isArray(arr[i])) { + flatten(arr[i], ret); + } else { + ret.push(arr[i]); + } + } + return ret; +} + +export type ArrayData = number|number[]|number[][]|number[][][]|number[][][][]; + +export function inferShape(arr: ArrayData): number[] { + const shape: number[] = []; + while (arr instanceof Array) { + shape.push(arr.length); + arr = arr[0]; + } + return shape; +} + +export function sizeFromShape(shape: number[]): number { + if (shape.length === 0) { + // Scalar. + return 1; + } + let size = shape[0]; + for (let i = 1; i < shape.length; i++) { + size *= shape[i]; + } + return size; +} + +export function isScalarShape(shape: number[]): boolean { + return shape.length === 0; +} + +// tslint:disable-next-line:no-any +export function arraysEqual(n1: any[]|Float32Array, n2: any[]|Float32Array) { + if (n1.length !== n2.length) { + return false; + } + for (let i = 0; i < n1.length; i++) { + if (n1[i] !== n2[i]) { + return false; + } + } + return true; +} + +export function isInt(a: number): boolean { + return a % 1 === 0; +} + +export function tanh(x: number): number { + // tslint:disable-next-line:no-any + if ((Math as any).tanh != null) { + // tslint:disable-next-line:no-any + return (Math as any).tanh(x); + } + if (x === Infinity) { + return 1; + } else if (x === -Infinity) { + return -1; + } else { + const e2x = Math.exp(2 * x); + return (e2x - 1) / (e2x + 1); + } +} + +export function sizeToSquarishShape(size: number): [number, number] { + for (let a = Math.floor(Math.sqrt(size)); a > 1; --a) { + if (size % a === 0) { + return [a, size / a]; + } + } + return [1, size]; +} + +export function createShuffledIndices(n: number): Uint32Array { + const shuffledIndices = new Uint32Array(n); + for (let i = 0; i < n; ++i) { + shuffledIndices[i] = i; + } + shuffle(shuffledIndices); + return shuffledIndices; +} diff --git a/src/util_test.ts b/src/util_test.ts new file mode 100644 index 0000000000..77e713c7f4 --- /dev/null +++ b/src/util_test.ts @@ -0,0 +1,89 @@ +/* Copyright 2017 Google Inc. 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. +==============================================================================*/ + +import * as util from './util'; + +describe('Util', () => { + + it('Flatten arrays', () => { + expect(util.flatten([[1, 2, 3], [4, 5, 6]])).toEqual([1, 2, 3, 4, 5, 6]); + expect(util.flatten([[[1, 2], [3, 4], [5, 6], [7, 8]]])).toEqual([ + 1, 2, 3, 4, 5, 6, 7, 8 + ]); + expect(util.flatten([1, 2, 3, 4, 5, 6])).toEqual([1, 2, 3, 4, 5, 6]); + }); + + it('Correctly gets size from shape', () => { + expect(util.sizeFromShape([1, 2, 3, 4])).toEqual(24); + }); + + it('Correctly identifies scalars', () => { + expect(util.isScalarShape([])).toBe(true); + expect(util.isScalarShape([1, 2])).toBe(false); + expect(util.isScalarShape([1])).toBe(false); + }); + + it('Number arrays equal', () => { + expect(util.arraysEqual([1, 2, 3, 6], [1, 2, 3, 6])).toBe(true); + expect(util.arraysEqual([1, 2], [1, 2, 3])).toBe(false); + expect(util.arraysEqual([1, 2, 5], [1, 2])).toBe(false); + }); + + it('Is integer', () => { + expect(util.isInt(0.5)).toBe(false); + expect(util.isInt(1)).toBe(true); + }); + + it('Size to squarish shape (perfect square)', () => { + expect(util.sizeToSquarishShape(9)).toEqual([3, 3]); + }); + + it('Size to squarish shape (prime number)', () => { + expect(util.sizeToSquarishShape(11)).toEqual([1, 11]); + }); + + it('Size to squarish shape (almost square)', () => { + expect(util.sizeToSquarishShape(35)).toEqual([5, 7]); + }); + + it('Size of 1 to squarish shape', () => { + expect(util.sizeToSquarishShape(1)).toEqual([1, 1]); + }); + + it('infer shape single number', () => { + expect(util.inferShape(4)).toEqual([]); + }); + + it('infer shape 1d array', () => { + expect(util.inferShape([1, 2, 5])).toEqual([3]); + }); + + it('infer shape 2d array', () => { + expect(util.inferShape([[1, 2, 5], [5, 4, 1]])).toEqual([2, 3]); + }); + + it('infer shape 3d array', () => { + const a = [[[1, 2], [2, 3], [5, 6]], [[5, 6], [4, 5], [1, 2]]]; + expect(util.inferShape(a)).toEqual([2, 3, 2]); + }); + + it('infer shape 4d array', () => { + const a = [ + [[[1], [2]], [[2], [3]], [[5], [6]]], + [[[5], [6]], [[4], [5]], [[1], [2]]] + ]; + expect(util.inferShape(a)).toEqual([2, 3, 2, 1]); + }); +}); diff --git a/tsconfig-doc.json b/tsconfig-doc.json new file mode 100644 index 0000000000..9f0896db5f --- /dev/null +++ b/tsconfig-doc.json @@ -0,0 +1,31 @@ +{ + "compilerOptions": { + "module": "commonjs", + "noImplicitAny": true, + "preserveConstEnums": true, + "sourceMap": true, + "target": "es5", + "lib": ["es2015", "dom"] + }, + "include": [ + "src/dataset.ts", + "src/math/conv_util.ts", + "src/math/webgl/gpgpu_util.ts", + "src/math/webgl/render_ndarray_gpu_util.ts", + "src/math/webgl/webgl_util.ts", + "src/util.ts", + "src/checkpoint_loader.ts", + "src/graph.ts", + "src/graph_runner.ts", + "src/initializers.ts", + "src/input_provider.ts", + "src/math/math.ts", + "src/math/math_cpu.ts", + "src/math/math_gpu.ts", + "src/math/ndarray.ts", + "src/math/webgl/gpgpu_context.ts", + "src/optimizer.ts", + "src/session.ts", + "src/sgd_optimizer.ts" + ] +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000000..31144e8bb4 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "module": "commonjs", + "noImplicitAny": true, + "sourceMap": true, + "removeComments": true, + "preserveConstEnums": true, + "declaration": true, + "target": "es5", + "lib": ["es2015", "dom"], + "outDir": "./dist" + } +} diff --git a/tslint.json b/tslint.json new file mode 100644 index 0000000000..95dc400777 --- /dev/null +++ b/tslint.json @@ -0,0 +1,55 @@ +{ + "rules": { + "array-type": [true, "array-simple"], + "arrow-return-shorthand": true, + "ban": [true, + ["fit"], + ["fdescribe"], + ["xit"], + ["xdescribe"], + ["fitAsync"], + ["xitAsync"], + ["fitFakeAsync"], + ["xitFakeAsync"] + ], + "ban-types": [true, + ["Object", "Use {} instead."], + ["String", "Use 'string' instead."], + ["Number", "Use 'number' instead."], + ["Boolean", "Use 'boolean' instead."] + ], + "class-name": true, + "interface-name": [true, "never-prefix"], + "jsdoc-format": true, + "label-position": true, + "new-parens": true, + "no-angle-bracket-type-assertion": true, + "no-any": true, + "no-construct": true, + "no-debugger": true, + "no-default-export": true, + "no-inferrable-types": true, + "no-namespace": [true, "allow-declarations"], + "no-reference": true, + "no-require-imports": true, + "no-string-throw": true, + "no-unused-expression": true, + "no-unused-variable": false, + "no-var-keyword": true, + "object-literal-shorthand": true, + "only-arrow-functions": [true, "allow-declarations", "allow-named-functions"], + "prefer-const": true, + "radix": true, + "semicolon": [true, "always", "ignore-bound-class-methods"], + "switch-default": true, + "triple-equals": [true, "allow-null-check"], + "use-isnan": true, + "variable-name": [ + true, + "check-format", + "ban-keywords", + "allow-leading-underscore", + "allow-trailing-underscore" + ] + } +}

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 JT^#-k{tqSfMsolF literal 0 HcmV?d00001 diff --git a/demos/mnist/hidden2_biases b/demos/mnist/hidden2_biases new file mode 100644 index 0000000000..5e90839228 --- /dev/null +++ b/demos/mnist/hidden2_biases @@ -0,0 +1 @@ +Ã`V»äˆ#;zú+9º×¼M®Ý=B!–¼fû¼A¸=‡Ê=¦T½²Ð^½tv=Ö(~¼ Ë:rm]=ßê=ý¦ˆ¹àÂ=#“\¼T2‡;òÈáZNh)SG3HC0$ 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 PkTu-c(TKY=RJi{EQ#u-X literal 0 HcmV?d00001 diff --git a/demos/mnist/index.html b/demos/mnist/index.html new file mode 100644 index 0000000000..898980bce2 --- /dev/null +++ b/demos/mnist/index.html @@ -0,0 +1,3 @@ +

_so$}Gr6G`|SZo3ihQSI51NY#fx; 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 aCRahz=O)>O;|p(`HQX|wLyY_y3>JaH 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